def test_cooperative_close_call_delegate( channel_params, get_accounts, uraiden_instance, get_channel): A = get_accounts(1, 5)[0] (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] sender_verified = uraiden_instance.call().extractBalanceProofSignature( receiver, open_block_number, balance, balance_msg_sig ) assert is_same_address(sender_verified, sender) receiver_verified = uraiden_instance.call().extractClosingSignature( sender, open_block_number, balance, closing_sig ) assert is_same_address(receiver_verified, receiver) # Cooperative close can be called by anyone uraiden_instance.transact({"from": A}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig )
def test_channel_erc20_topup_delegate( owner, uraiden_instance, token_instance, delegate_instance, get_channel): deposit = 1000 deposit_topup = 200 (sender, receiver, open_block_number) = get_channel(uraiden_instance, token_instance, deposit)[:3] # Delegate contract is a trusted contract assert uraiden_instance.call().trusted_contracts(delegate_instance.address) # Fund delegate with tokens token_instance.transact({"from": owner}).transfer(delegate_instance.address, deposit_topup) # Top up channel through delegate delegate_instance.transact({"from": sender}).topUpERC20( sender, receiver, open_block_number, deposit_topup ) # Check channel deposit channel_data = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_data[1] == deposit + deposit_topup
def test_uncooperative_close_fail_in_challenge_period( channel_params, get_accounts, uraiden_instance, token_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] # Should fail if the channel is already in a challenge period uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) channel_info = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_info[2] > 0 # settle_block_number with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance )
def test_withdraw_fail_in_challenge_period( channel_params, get_accounts, uraiden_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance = 30 balance_message_hash = balance_proof_hash( receiver, open_block_number, balance, uraiden_instance.address ) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) assert is_same_address(addr, sender) # Should fail if the channel is already in a challenge period uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) channel_info = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_info[2] > 0 # settle_block_number with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance, balance_msg_sig )
def test_settle_call( web3, contract_params, channel_params, uraiden_instance, token_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number) # Trigger a challenge period uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) web3.testing.mine(contract_params['challenge_period'] + 1) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).settle(0x0, open_block_number) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).settle(fake_address, open_block_number) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).settle(receiver, -2) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).settle(receiver, MAX_UINT32 + 1) uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number)
def test_settle_event( web3, channel_params, contract_params, uraiden_instance, get_channel, event_handler): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] ev_handler = event_handler(uraiden_instance) # Trigger a challenge period uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) web3.testing.mine(contract_params['challenge_period'] + 1) txn_hash = uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number) ev_handler.add(txn_hash, uraiden_events['settled'], checkSettledEvent( sender, receiver, open_block_number, balance, balance) ) ev_handler.check()
def test_cooperative_close_event( channel_params, uraiden_instance, get_channel, event_handler): (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] ev_handler = event_handler(uraiden_instance) txn_hash = uraiden_instance.transact({"from": receiver}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig ) ev_handler.add(txn_hash, uraiden_events['settled'], checkClosedEvent( sender, receiver, open_block_number, balance) ) ev_handler.check()
def test_cooperative_close_fail_no_channel( channel_params, get_accounts, uraiden_instance, get_channel): A = get_accounts(1, 5)[0] (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] # Should fail if the channel does not exist with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( A, open_block_number, balance, balance_msg_sig, closing_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number - 1, balance, balance_msg_sig, closing_sig ) uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig )
def test_withdraw_event( channel_params, uraiden_instance, get_channel, event_handler): (sender, receiver, open_block_number) = get_channel()[:3] ev_handler = event_handler(uraiden_instance) balance = 30 balance_message_hash = balance_proof_hash( receiver, open_block_number, balance, uraiden_instance.address ) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) assert is_same_address(addr, sender) txn_hash = uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance, balance_msg_sig ) ev_handler.add(txn_hash, uraiden_events['withdraw'], checkWithdrawEvent( sender, receiver, open_block_number, balance) ) ev_handler.check()
def test_cooperative_close_fail_diff_receiver( channel_params, get_accounts, uraiden_instance, get_channel): A = get_accounts(1, 5)[0] (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] balance_message_hash_A = balance_proof_hash( A, open_block_number, balance, uraiden_instance.address ) balance_msg_sig_A, addr = sign.check(balance_message_hash_A, tester.k2) # Should fail if someone tries to use a closing signature from another receiver # with the same sender, block, balance with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( A, open_block_number, balance, balance_msg_sig_A, closing_sig )
def test_settle_fail_in_challenge( web3, contract_params, channel_params, uraiden_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] # Trigger a challenge period uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number) web3.testing.mine(contract_params['challenge_period'] - 1) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number) web3.testing.mine(1) uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number)
def test_cooperative_close_call_receiver( channel_params, get_accounts, uraiden_instance, get_channel, print_gas): (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] sender_verified = uraiden_instance.call().extractBalanceProofSignature( receiver, open_block_number, balance, balance_msg_sig ) assert is_same_address(sender_verified, sender) receiver_verified = uraiden_instance.call().extractClosingSignature( sender, open_block_number, balance, closing_sig ) assert is_same_address(receiver_verified, receiver) # Cooperative close can be called by anyone txn_hash = uraiden_instance.transact({"from": receiver}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig ) print_gas(txn_hash, 'cooperativeClose')
def test_balance_remaining_big( channel_params, get_accounts, uraiden_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance1 = 30 balance2_big = channel_params['deposit'] + 1 balance2_ok = channel_params['deposit'] balance_message_hash1 = balance_proof_hash( receiver, open_block_number, balance1, uraiden_instance.address ) balance_msg_sig1, addr = sign.check(balance_message_hash1, tester.k2) assert is_same_address(addr, sender) balance_message_hash2_big = balance_proof_hash( receiver, open_block_number, balance2_big, uraiden_instance.address ) balance_msg_sig2_big, addr = sign.check(balance_message_hash2_big, tester.k2) assert is_same_address(addr, sender) balance_message_hash2_ok = balance_proof_hash( receiver, open_block_number, balance2_ok, uraiden_instance.address ) balance_msg_sig2_ok, addr = sign.check(balance_message_hash2_ok, tester.k2) assert is_same_address(addr, sender) uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance1, balance_msg_sig1 ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance2_big, balance_msg_sig2_big ) uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance2_ok, balance_msg_sig2_ok )
def test_cooperative_close_state( web3, contract_params, channel_params, uraiden_instance, token_instance, get_channel, get_block): (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] deposit = channel_params['deposit'] # Keep track of pre closing balances receiver_pre_balance = token_instance.call().balanceOf(receiver) sender_pre_balance = token_instance.call().balanceOf(sender) contract_pre_balance = token_instance.call().balanceOf(uraiden_instance.address) # Cooperative close can be called by anyone uraiden_instance.transact({"from": receiver}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig ) # Check post closing balances receiver_post_balance = receiver_pre_balance + balance sender_post_balance = sender_pre_balance + (deposit - balance) contract_post_balance = contract_pre_balance - deposit assert token_instance.call().balanceOf(receiver) == receiver_post_balance assert token_instance.call().balanceOf(sender) == sender_post_balance assert token_instance.call().balanceOf(uraiden_instance.address) == contract_post_balance channel_settle_tests(uraiden_instance, token_instance, (sender, receiver, open_block_number) ) # Channel does not exist anymore, so this will fail with pytest.raises(tester.TransactionFailed): uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) web3.testing.mine(30) # Cannot be called another time with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig )
def test_function_access( owner, get_accounts, uraiden_contract, uraiden_instance, token_instance, get_channel): (A, B, C, D) = get_accounts(4) uraiden_instance2 = uraiden_contract() channel = get_channel(uraiden_instance, token_instance, 100, A, B)[:3] (sender, receiver, open_block_number) = channel uraiden_instance.call().getKey(*channel) uraiden_instance.call().getChannelInfo(*channel) # even if TransactionFailed , this means the function is public / external with pytest.raises(tester.TransactionFailed): uraiden_instance.transact().extractBalanceProofSignature( receiver, open_block_number, 10, encode_hex(bytearray(65)) ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact().tokenFallback(sender, 10, encode_hex(bytearray(20))) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': C}).createChannel(D, 10) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact().topUp(receiver, open_block_number, 10) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact().uncooperativeClose(receiver, open_block_number, 10) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact().cooperativeClose( receiver, open_block_number, 10, encode_hex(bytearray(65)), encode_hex(bytearray(65)) ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact().settle(receiver, open_block_number) # Test functions are private # raise ValueError("No matching functions found") with pytest.raises(ValueError): uraiden_instance.transact().createChannelPrivate(*channel) with pytest.raises(ValueError): uraiden_instance.transact().topUpPrivate(*channel, 10) with pytest.raises(ValueError): uraiden_instance.transact().initChallengePeriod(receiver, open_block_number, 10) with pytest.raises(ValueError): uraiden_instance.transact().settleChannel(*channel, 10)
def test_settle_state( web3, channel_params, contract_params, uraiden_instance, token_instance, get_channel, print_gas): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] deposit = channel_params['deposit'] # Trigger a challenge period uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) web3.testing.mine(contract_params['challenge_period'] + 1) # Keep track of pre closing balances receiver_pre_balance = token_instance.call().balanceOf(receiver) sender_pre_balance = token_instance.call().balanceOf(sender) contract_pre_balance = token_instance.call().balanceOf(uraiden_instance.address) txn_hash = uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number) # Check post closing balances receiver_post_balance = receiver_pre_balance + balance sender_post_balance = sender_pre_balance + (deposit - balance) contract_post_balance = contract_pre_balance - deposit assert token_instance.call().balanceOf(receiver) == receiver_post_balance assert token_instance.call().balanceOf(sender) == sender_post_balance assert token_instance.call().balanceOf(uraiden_instance.address) == contract_post_balance channel_settle_tests(uraiden_instance, token_instance, (sender, receiver, open_block_number) ) # Channel does not exist anymore, so this will fail with pytest.raises(tester.TransactionFailed): uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) web3.testing.mine(30) # Cannot be called another time with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).settle(receiver, open_block_number) print_gas(txn_hash, 'settle')
def test_withdraw_call(channel_params, uraiden_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance = 30 balance_message_hash = balance_proof_hash( receiver, open_block_number, balance, uraiden_instance.address ) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) assert is_same_address(addr, sender) with pytest.raises(TypeError): uraiden_instance.transact({"from": receiver}).withdraw( -2, balance, balance_msg_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": receiver}).withdraw( MAX_UINT32 + 1, balance, balance_msg_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, -1, balance_msg_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance, encode_hex(bytearray()) ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, 0, balance_msg_sig ) uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance, balance_msg_sig )
def test_channel_topup_20_bounty_limit( get_accounts, owner, uraiden_instance, token_instance, get_channel): token = token_instance (sender, receiver, A) = get_accounts(3) channel_deposit = 1 channel = get_channel(uraiden_instance, token_instance, channel_deposit, sender, receiver)[:3] (sender, receiver, open_block_number) = channel # See how many tokens we need to reach channel_deposit_bugbounty_limit added_deposit = channel_deposit_bugbounty_limit - channel_deposit # Fund accounts with tokens token.transact({"from": owner}).transfer(sender, added_deposit + 1) # Approve token allowance txn_hash = token.transact({"from": sender}).approve(uraiden_instance.address, added_deposit + 1) pre_balance = token.call().balanceOf(uraiden_instance.address) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': sender}).topUp( receiver, open_block_number, added_deposit + 1 ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': sender}).topUp( receiver, open_block_number, added_deposit + 50 ) uraiden_instance.transact({'from': sender}).topUp( receiver, open_block_number, added_deposit ) post_balance = pre_balance + added_deposit assert token_instance.call().balanceOf(uraiden_instance.address) == post_balance channel_data = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_data[1] == channel_deposit_bugbounty_limit
def test_channel_topup_223_bounty_limit( get_accounts, owner, uraiden_instance, token_instance, get_channel): token = token_instance (sender, receiver, A) = get_accounts(3) channel_deposit = 1 channel = get_channel(uraiden_instance, token_instance, channel_deposit, sender, receiver)[:3] (sender, receiver, open_block_number) = channel top_up_data = sender[2:] + receiver[2:] + hex(open_block_number)[2:].zfill(8) top_up_data = bytes.fromhex(top_up_data) # See how many tokens we need to reach channel_deposit_bugbounty_limit added_deposit = channel_deposit_bugbounty_limit - channel_deposit # Fund accounts with tokens token.transact({"from": owner}).transfer(sender, added_deposit + 1) pre_balance = token.call().balanceOf(uraiden_instance.address) with pytest.raises(tester.TransactionFailed): token_instance.transact({"from": sender}).transfer( uraiden_instance.address, added_deposit + 1, top_up_data ) with pytest.raises(tester.TransactionFailed): token_instance.transact({"from": sender}).transfer( uraiden_instance.address, added_deposit + 20, top_up_data ) token_instance.transact({"from": sender}).transfer( uraiden_instance.address, added_deposit, top_up_data ) post_balance = pre_balance + added_deposit assert token_instance.call().balanceOf(uraiden_instance.address) == post_balance channel_data = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_data[1] == channel_deposit_bugbounty_limit
def test_uncooperative_close_call(channel_params, uraiden_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).uncooperativeClose( 0x0, open_block_number, balance ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).uncooperativeClose( fake_address, open_block_number, balance ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, -2, balance ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, MAX_UINT32 + 1, balance ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, -2 ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, MAX_UINT256 + 1 ) uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance )
def test_withdraw_fail_no_channel( channel_params, get_accounts, uraiden_instance, get_channel): A = get_accounts(1, 5)[0] (sender, receiver, open_block_number) = get_channel()[:3] balance = 10 balance_message_hash_A = balance_proof_hash( A, open_block_number, balance, uraiden_instance.address ) balance_msg_sig_A, addr = sign.check(balance_message_hash_A, tester.k5) assert is_same_address(addr, A) balance_message_hash = balance_proof_hash( receiver, open_block_number, balance, uraiden_instance.address ) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) assert is_same_address(addr, sender) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).withdraw( open_block_number, balance, balance_msg_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": A}).withdraw( open_block_number, balance, balance_msg_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance, balance_msg_sig_A )
def test_channel_topup_223( get_accounts, uraiden_instance, token_instance, get_channel, event_handler, print_gas): token = token_instance ev_handler = event_handler(uraiden_instance) (sender, receiver, A, B) = get_accounts(4) channel_deposit = 700 channel = get_channel(uraiden_instance, token_instance, channel_deposit, sender, receiver)[:3] (sender, receiver, open_block_number) = channel top_up_deposit = 14 # address 20 bytes # padded block number from uint32 (4 bytes) to 32 bytes top_up_data = sender[2:] + receiver[2:] + hex(open_block_number)[2:].zfill(8) top_up_data = bytes.fromhex(top_up_data) top_up_data_wrong_receiver = sender[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(uraiden_instance.address, top_up_deposit, top_up_data_wrong_receiver) with pytest.raises(tester.TransactionFailed): token.transact({"from": sender}).transfer(uraiden_instance.address, top_up_deposit, top_up_data_wrong_block) with pytest.raises(tester.TransactionFailed): token.transact({"from": sender}).transfer(uraiden_instance.address, 0, top_up_data) # Call Token - this calls uraiden_instance.tokenFallback txn_hash = token.transact({"from": sender}).transfer(uraiden_instance.address, top_up_deposit, top_up_data) channel_data = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_data[1] == channel_deposit + top_up_deposit # deposit print_gas(txn_hash, 'test_channel_topup_223') # Check topup event ev_handler.add(txn_hash, uraiden_events['topup'], checkToppedUpEvent(sender, receiver, open_block_number, top_up_deposit, channel_deposit + top_up_deposit)) ev_handler.check()
def test_uncooperative_close_fail_no_channel( channel_params, get_accounts, uraiden_instance, get_channel): A = get_accounts(1, 5)[0] (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] # Should fail if called by anyone else than the sender with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": receiver}).uncooperativeClose( receiver, open_block_number, balance ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": A}).uncooperativeClose( receiver, open_block_number, balance ) # Should fail if the channel does not exist with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).uncooperativeClose( A, open_block_number, balance ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number - 1, balance ) uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance )
def test_get_channel_info(web3, get_accounts, uraiden_instance, token_instance, get_channel): (A, B, C, D) = get_accounts(4) channel = get_channel(uraiden_instance, token_instance, 100, C, D)[:3] (sender, receiver, open_block_number) = channel with pytest.raises(tester.TransactionFailed): uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number-2) web3.testing.mine(2) with pytest.raises(tester.TransactionFailed): uraiden_instance.call().getChannelInfo(A, receiver, open_block_number) web3.testing.mine(2) with pytest.raises(tester.TransactionFailed): uraiden_instance.call().getChannelInfo(sender, A, open_block_number) web3.testing.mine(2) channel_data = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_data[0] == uraiden_instance.call().getKey(sender, receiver, open_block_number) assert channel_data[1] == 100 assert channel_data[2] == 0 assert channel_data[3] == 0 assert channel_data[4] == 0
def test_uncooperative_close_fail_big_balance( channel_params, get_accounts, uraiden_instance, token_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] deposit = channel_params['deposit'] with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, deposit + 1 ) uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, deposit )
def test_uncooperative_close_state( contract_params, channel_params, uraiden_instance, get_channel, get_block, print_gas): (sender, receiver, open_block_number) = get_channel()[:3] balance = channel_params['balance'] txn_hash = uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance ) channel_info = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) # settle_block_number assert channel_info[2] == get_block(txn_hash) + contract_params['challenge_period'] # closing_balance assert channel_info[3] == balance print_gas(txn_hash, 'uncooperativeClose')
def test_uncooperative_close_uint32_overflow( web3, channel_params, get_uraiden_contract, token_instance, get_channel): challenge_period = MAX_UINT32 - 20 uraiden_instance = get_uraiden_contract( [token_instance.address, challenge_period, []] ) (sender, receiver, open_block_number) = get_channel(uraiden_instance)[:3] balance = channel_params['balance'] block_number = web3.eth.getBlock('latest')['number'] web3.testing.mine(MAX_UINT32 - 1 - block_number - challenge_period) assert web3.eth.getBlock('latest')['number'] + challenge_period == MAX_UINT32 - 1 uraiden_instance.transact({"from": sender}).uncooperativeClose( receiver, open_block_number, balance )
def test_channel_topup_20( get_accounts, uraiden_instance, token_instance, get_channel, txn_gas, event_handler, print_gas): token = token_instance ev_handler = event_handler(uraiden_instance) (sender, receiver, A) = get_accounts(3) channel_deposit = 999 channel = get_channel(uraiden_instance, token_instance, channel_deposit, sender, receiver)[:3] (sender, receiver, open_block_number) = channel top_up_deposit = 14 with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': sender}).topUp( receiver, open_block_number, top_up_deposit ) # Approve token allowance txn_hash = token.transact({"from": sender}).approve(uraiden_instance.address, top_up_deposit) gas_used_approve = txn_gas(txn_hash) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).topUp(0x0, top_up_deposit) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).topUp('0x0', top_up_deposit) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).topUp(fake_address, top_up_deposit) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).topUp(receiver, -3) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).topUp(receiver, MAX_UINT192 + 1) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': A}).topUp(receiver, open_block_number, top_up_deposit) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': sender}).topUp(A, open_block_number, top_up_deposit) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': sender}).topUp(receiver, open_block_number, 0) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({'from': sender}).topUp(receiver, 0, top_up_deposit) txn_hash = uraiden_instance.transact({'from': sender}).topUp( receiver, open_block_number, top_up_deposit ) channel_data = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) assert channel_data[1] == channel_deposit + top_up_deposit # deposit print_gas(txn_hash, 'test_channel_topup_20', gas_used_approve) # Check topup event ev_handler.add(txn_hash, uraiden_events['topup'], checkToppedUpEvent( sender, receiver, open_block_number, top_up_deposit, channel_deposit + top_up_deposit) ) ev_handler.check()
def test_cooperative_close_call(channel_params, uraiden_instance, get_channel): (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).cooperativeClose( 0x0, open_block_number, balance, balance_msg_sig, closing_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).cooperativeClose( fake_address, open_block_number, balance, balance_msg_sig, closing_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, -2, balance, balance_msg_sig, closing_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, MAX_UINT32 + 1, balance, balance_msg_sig, closing_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, -2, balance_msg_sig, closing_sig ) with pytest.raises(TypeError): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, MAX_UINT256 + 1, balance_msg_sig, closing_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, encode_hex(bytearray()), closing_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, encode_hex(bytearray()) ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, encode_hex(bytearray(64)), closing_sig ) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, encode_hex(bytearray(64)) ) uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig )
def test_cooperative_close_fail_wrong_balance( channel_params, get_accounts, uraiden_instance, token_instance, get_channel): (sender, receiver, open_block_number, balance_msg_sig, closing_sig) = get_channel() balance = channel_params['balance'] deposit = channel_params['deposit'] balance_message_hash_fake = balance_proof_hash( receiver, open_block_number, balance - 1, uraiden_instance.address ) balance_msg_sig_fake, addr = sign.check(balance_message_hash_fake, tester.k2) closing_msg_hash_fake = closing_message_hash( sender, open_block_number, balance - 1, uraiden_instance.address ) closing_sig_fake, addr = sign.check(closing_msg_hash_fake, tester.k3) # Wrong balance as an argument with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance + 1, balance_msg_sig, closing_sig ) # Sender signs wrong balance with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig_fake, closing_sig ) # Receiver signs wrong balance with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig_fake ) uraiden_instance.transact({"from": sender}).cooperativeClose( receiver, open_block_number, balance, balance_msg_sig, closing_sig )