def test_channel_erc20_event( owner, get_accounts, uraiden_instance, token_instance, event_handler, txn_gas, print_gas): token = token_instance ev_handler = event_handler(uraiden_instance) (sender, receiver) = get_accounts(2) deposit = 1000 gas_used = 0 # Fund accounts with tokens token.transact({"from": owner}).transfer(sender, deposit + 100) # Approve token allowance txn_hash_approve = token_instance.transact({"from": sender}).approve(uraiden_instance.address, deposit) gas_used += txn_gas(txn_hash_approve) # Create channel txn_hash = uraiden_instance.transact({"from": sender}).createChannel(receiver, deposit) # Check creation event ev_handler.add( txn_hash, uraiden_events['created'], checkCreatedEvent(sender, receiver, deposit) ) ev_handler.check() print_gas(txn_hash, 'channel_20_create', gas_used)
def test_add_trusted_contracts_state(owner, get_accounts, uraiden_instance, delegate_contract, print_gas): (A, B) = get_accounts(2) trusted_contract1 = delegate_contract() trusted_contract2 = delegate_contract() trusted_contract3 = delegate_contract() trusted_contract4 = delegate_contract() assert not uraiden_instance.call().trusted_contracts(trusted_contract1.address) assert not uraiden_instance.call().trusted_contracts(trusted_contract2.address) assert not uraiden_instance.call().trusted_contracts(trusted_contract3.address) assert not uraiden_instance.call().trusted_contracts(trusted_contract4.address) uraiden_instance.transact({'from': owner}).addTrustedContracts([A]) assert not uraiden_instance.call().trusted_contracts(A) txn_hash = uraiden_instance.transact({'from': owner}).addTrustedContracts([trusted_contract1.address]) assert uraiden_instance.call().trusted_contracts(trusted_contract1.address) print_gas(txn_hash, 'add 1 trusted contract') txn_hash = uraiden_instance.transact({'from': owner}).addTrustedContracts([ trusted_contract2.address, trusted_contract3.address, A, trusted_contract4.address ]) assert uraiden_instance.call().trusted_contracts(trusted_contract2.address) assert uraiden_instance.call().trusted_contracts(trusted_contract3.address) assert uraiden_instance.call().trusted_contracts(trusted_contract4.address) assert not uraiden_instance.call().trusted_contracts(A) print_gas(txn_hash, 'add 3 trusted contracts')
def test_channel_erc223_event( owner, get_accounts, uraiden_instance, token_instance, event_handler, print_gas): token = token_instance ev_handler = event_handler(uraiden_instance) (sender, receiver) = get_accounts(2) deposit = 1000 txdata = bytes.fromhex(sender[2:] + receiver[2:]) # Fund accounts with tokens token.transact({"from": owner}).transfer(sender, deposit + 100) txn_hash = token_instance.transact({"from": sender}).transfer( uraiden_instance.address, 1000, txdata ) # Check creation event ev_handler.add( txn_hash, uraiden_events['created'], checkCreatedEvent(sender, receiver, deposit) ) ev_handler.check() print_gas(txn_hash, 'channel_223_create')
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_channel_erc20_event(owner, get_accounts, uraiden_instance, token_instance, event_handler, txn_gas, print_gas): token = token_instance ev_handler = event_handler(uraiden_instance) (sender, receiver) = get_accounts(2) deposit = 1000 gas_used = 0 # Fund accounts with tokens token.transact({"from": owner}).transfer(sender, deposit + 100) # Approve token allowance txn_hash_approve = token_instance.transact({ "from": sender }).approve(uraiden_instance.address, deposit) gas_used += txn_gas(txn_hash_approve) # Create channel txn_hash = uraiden_instance.transact({ "from": sender }).createChannelERC20(receiver, deposit) # Check creation event ev_handler.add(txn_hash, uraiden_events['created'], checkCreatedEvent(sender, receiver, deposit)) ev_handler.check() print_gas(txn_hash, 'channel_20_create', gas_used)
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_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_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_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_add_trusted_contracts_state(owner, get_accounts, uraiden_instance, delegate_contract, print_gas): (A, B) = get_accounts(2) trusted_contract1 = delegate_contract() trusted_contract2 = delegate_contract() trusted_contract3 = delegate_contract() trusted_contract4 = delegate_contract() assert not uraiden_instance.call().trusted_contracts( trusted_contract1.address) assert not uraiden_instance.call().trusted_contracts( trusted_contract2.address) assert not uraiden_instance.call().trusted_contracts( trusted_contract3.address) assert not uraiden_instance.call().trusted_contracts( trusted_contract4.address) uraiden_instance.transact({'from': owner}).addTrustedContracts([A]) assert not uraiden_instance.call().trusted_contracts(A) txn_hash = uraiden_instance.transact({ 'from': owner }).addTrustedContracts([trusted_contract1.address]) assert uraiden_instance.call().trusted_contracts(trusted_contract1.address) print_gas(txn_hash, 'add 1 trusted contract') txn_hash = uraiden_instance.transact({ 'from': owner }).addTrustedContracts([ trusted_contract2.address, trusted_contract3.address, A, trusted_contract4.address ]) assert uraiden_instance.call().trusted_contracts(trusted_contract2.address) assert uraiden_instance.call().trusted_contracts(trusted_contract3.address) assert uraiden_instance.call().trusted_contracts(trusted_contract4.address) assert not uraiden_instance.call().trusted_contracts(A) print_gas(txn_hash, 'add 3 trusted contracts')
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_close_by_sender(get_accounts, uraiden_instance, token_instance, get_channel, print_gas, event_handler): token = token_instance (sender, receiver, A) = get_accounts(3) ev_handler = event_handler(uraiden_instance) channel_deposit = 800 top_up_deposit = 14 channel = get_channel(uraiden_instance, token_instance, channel_deposit, sender, receiver) (sender, receiver, open_block_number) = channel balance = channel_deposit - 1 balance_message_hash = balance_proof_hash(receiver, open_block_number, balance, uraiden_instance.address) balance_message_hash_false_receiver = balance_proof_hash( A, open_block_number, balance, uraiden_instance.address) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) balance_msg_sig_false_signer, addr = sign.check(balance_message_hash, tester.k4) balance_msg_sig_false_receiver, addr = sign.check( balance_message_hash_false_receiver, tester.k4) closing_sig, addr = sign.check(sol_sha3(balance_msg_sig), tester.k3) closing_sig_false_signer, addr = sign.check(sol_sha3(balance_msg_sig), tester.k4) closing_sig_false_receiver, addr = sign.check( sol_sha3(balance_msg_sig_false_receiver), tester.k3) 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 - 3, balance, balance_msg_sig, closing_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': sender }).cooperativeClose(receiver, open_block_number, balance + 5, balance_msg_sig, closing_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': sender }).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig_false_signer, closing_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': sender }).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig_false_receiver, closing_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': sender }).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig_false_signer) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': sender }).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig_false_receiver) channel_pre_close_tests(uraiden_instance, token_instance, channel, top_up_deposit) receiver_pre_balance = token.call().balanceOf(receiver) sender_pre_balance = token.call().balanceOf(sender) contract_pre_balance = token.call().balanceOf(uraiden_instance.address) txn_hash = uraiden_instance.transact({ 'from': sender }).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig) # TODO: raise Exception # ev_handler.add(txn_hash, uraiden_events['closed'], checkClosedEvent(sender, receiver, open_block_number, balance)) # ev_handler.check() channel_deposit += top_up_deposit receiver_post_balance = receiver_pre_balance + balance sender_post_balance = sender_pre_balance + (channel_deposit - balance) contract_post_balance = contract_pre_balance - channel_deposit assert token.call().balanceOf(receiver) == receiver_post_balance assert token.call().balanceOf(sender) == sender_post_balance assert token.call().balanceOf( uraiden_instance.address) == contract_post_balance channel_settle_tests(uraiden_instance, token_instance, channel) ev_handler.add( txn_hash, uraiden_events['settled'], checkSettledEvent(sender, receiver, open_block_number, balance)) ev_handler.check() print_gas(txn_hash, 'test_close_by_sender')
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 get(uraiden_instance, token_instance, deposit, sender=None, receiver=None): contract_type = request.param ev_handler = event_handler(uraiden_instance) gas_used_create = 0 if not sender: (sender, receiver) = get_accounts(2) # Supply accounts with tokens token_instance.transact({"from": owner}).transfer(sender, deposit + 500) token_instance.transact({"from": owner}).transfer(receiver, 100) # Memorize balances for tests uraiden_pre_balance = token_instance.call().balanceOf(uraiden_instance.address) sender_pre_balance = token_instance.call().balanceOf(sender) receiver_pre_balance = token_instance.call().balanceOf(receiver) # Create channel (ERC20 or ERC223 logic) if contract_type == '20': txn_hash = token_instance.transact({"from": sender}).approve( uraiden_instance.address, deposit ) gas_used_create += txn_gas(txn_hash) txn_hash = uraiden_instance.transact({"from": sender}).createChannelERC20( receiver, deposit ) message = 'test_channel_20_create' else: txdata = receiver[2:].zfill(40) txdata = bytes.fromhex(txdata) txn_hash = token_instance.transact({"from": sender}).transfer( uraiden_instance.address, deposit, txdata ) message = 'test_channel_223_create' # Check token balances post channel creation uraiden_balance = uraiden_pre_balance + deposit assert token_instance.call().balanceOf(uraiden_instance.address) == uraiden_balance assert token_instance.call().balanceOf(sender) == sender_pre_balance - deposit assert token_instance.call().balanceOf(receiver) == receiver_pre_balance # Check creation event ev_handler.add( txn_hash, uraiden_events['created'], checkCreatedEvent(sender, receiver, deposit) ) ev_handler.check() open_block_number = get_block(txn_hash) 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] == deposit assert channel_data[2] == 0 assert channel_data[3] == 0 print_gas(txn_hash, message, gas_used_create) return (sender, receiver, open_block_number)
def test_withdraw_state(contract_params, channel_params, uraiden_instance, token_instance, get_channel, get_block, print_gas): (sender, receiver, open_block_number) = get_channel()[:3] deposit = channel_params['deposit'] balance1 = 20 balance2 = deposit balance_message_hash = balance_proof_hash(receiver, open_block_number, balance1, uraiden_instance.address) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) assert is_same_address(addr, sender) # Memorize balances for tests uraiden_pre_balance = token_instance.call().balanceOf( uraiden_instance.address) sender_pre_balance = token_instance.call().balanceOf(sender) receiver_pre_balance = token_instance.call().balanceOf(receiver) txn_hash = uraiden_instance.transact({ "from": receiver }).withdraw(open_block_number, balance1, balance_msg_sig) # Check channel info channel_info = uraiden_instance.call().getChannelInfo( sender, receiver, open_block_number) # deposit assert channel_info[1] == deposit assert channel_info[2] == 0 assert channel_info[3] == 0 assert channel_info[4] == balance1 # Check token balances post withrawal uraiden_balance = uraiden_pre_balance - balance1 assert token_instance.call().balanceOf( uraiden_instance.address) == uraiden_balance assert token_instance.call().balanceOf(sender) == sender_pre_balance assert token_instance.call().balanceOf( receiver) == receiver_pre_balance + balance1 print_gas(txn_hash, 'withdraw') balance_message_hash = balance_proof_hash(receiver, open_block_number, balance2, 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, balance2, balance_msg_sig) channel_info = uraiden_instance.call().getChannelInfo( sender, receiver, open_block_number) # deposit assert channel_info[1] == deposit assert channel_info[2] == 0 assert channel_info[3] == 0 assert channel_info[4] == balance2 # Check token balances post withrawal uraiden_balance = uraiden_pre_balance - deposit assert token_instance.call().balanceOf( uraiden_instance.address) == uraiden_balance assert token_instance.call().balanceOf(sender) == sender_pre_balance assert token_instance.call().balanceOf( receiver) == receiver_pre_balance + deposit print_gas(txn_hash, 'withdraw')
def test_close_by_receiver(get_accounts, uraiden_instance, token_instance, get_channel, print_gas, event_handler): token = token_instance (sender, receiver, A) = get_accounts(3) ev_handler = event_handler(uraiden_instance) channel_deposit = 800 top_up_deposit = 14 channel = get_channel(uraiden_instance, token_instance, channel_deposit, sender, receiver) (sender, receiver, open_block_number) = channel channel_pre_close_tests(uraiden_instance, token_instance, channel, top_up_deposit) balance = channel_deposit - 1 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) balance_msg_sig_false, addr2 = sign.check(balance_message_hash, tester.k4) assert addr == sender contract_verified_address = uraiden_instance.call().verifyBalanceProof( receiver, open_block_number, balance, balance_msg_sig) assert contract_verified_address == sender with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': A }).uncooperativeClose(receiver, open_block_number, balance, balance_msg_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': receiver }).uncooperativeClose(receiver, open_block_number + 1, balance, balance_msg_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': receiver }).uncooperativeClose(receiver, open_block_number, balance + 1, balance_msg_sig) with pytest.raises(tester.TransactionFailed): uraiden_instance.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(uraiden_instance.address) txn_hash = uraiden_instance.transact({ 'from': receiver }).uncooperativeClose(receiver, open_block_number, balance, balance_msg_sig) channel_deposit += top_up_deposit receiver_post_balance = receiver_pre_balance + balance sender_post_balance = sender_pre_balance + (channel_deposit - balance) contract_post_balance = contract_pre_balance - channel_deposit assert token.call().balanceOf(receiver) == receiver_post_balance assert token.call().balanceOf(sender) == sender_post_balance assert token.call().balanceOf( uraiden_instance.address) == contract_post_balance channel_settle_tests(uraiden_instance, token_instance, channel) # TODO: # with pytest.raises(Exception): # ev_handler.add(txn_hash, uraiden_events['closed'], checkClosedEvent(sender, receiver, open_block_number, balance)) ev_handler.add( txn_hash, uraiden_events['settled'], checkSettledEvent(sender, receiver, open_block_number, balance)) ev_handler.check() print_gas(txn_hash, 'test_close_by_receiver')
def test_close_by_sender_challenge_settle_by_sender2( web3, contract_params, get_accounts, uraiden_instance, token_instance, get_channel, print_gas, txn_gas, event_handler): token = token_instance ev_handler = event_handler(uraiden_instance) channel_deposit = 800 top_up_deposit = 14 channel = get_channel(uraiden_instance, token_instance, channel_deposit) (sender, receiver, open_block_number) = channel balance = 0 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) channel_pre_close_tests(uraiden_instance, token_instance, channel, top_up_deposit) txn_hash1 = uraiden_instance.transact({ 'from': sender }).uncooperativeClose(receiver, open_block_number, balance, balance_msg_sig) channel_data = uraiden_instance.call().getChannelInfo( sender, receiver, open_block_number) assert channel_data[2] != 0 # settle_block_number ev_handler.add( txn_hash1, uraiden_events['closed'], checkClosedEvent(sender, receiver, open_block_number, balance)) ev_handler.check() with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': sender }).settle(receiver, open_block_number) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': receiver }).settle(receiver, open_block_number) web3.testing.mine(contract_params['challenge_period'] + 1) with pytest.raises(tester.TransactionFailed): uraiden_instance.transact({ 'from': receiver }).settle(receiver, open_block_number) receiver_pre_balance = token.call().balanceOf(receiver) sender_pre_balance = token.call().balanceOf(sender) contract_pre_balance = token.call().balanceOf(uraiden_instance.address) txn_hash2 = uraiden_instance.transact({ 'from': sender }).settle(receiver, open_block_number) channel_deposit += top_up_deposit receiver_post_balance = receiver_pre_balance + balance sender_post_balance = sender_pre_balance + (channel_deposit - balance) contract_post_balance = contract_pre_balance - channel_deposit assert token.call().balanceOf(receiver) == receiver_post_balance assert token.call().balanceOf(sender) == sender_post_balance assert token.call().balanceOf( uraiden_instance.address) == contract_post_balance channel_settle_tests(uraiden_instance, token_instance, channel) ev_handler.add( txn_hash2, uraiden_events['settled'], checkSettledEvent(sender, receiver, open_block_number, balance)) ev_handler.check() print_gas(txn_hash1, 'test_close_by_sender_challenge_settle_by_sender2', txn_gas(txn_hash2))
def test_withdraw_state( contract_params, channel_params, uraiden_instance, token_instance, get_channel, get_block, print_gas): (sender, receiver, open_block_number) = get_channel()[:3] deposit = channel_params['deposit'] balance1 = 20 balance2 = deposit balance_message_hash = balance_proof_hash( receiver, open_block_number, balance1, uraiden_instance.address ) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k2) assert is_same_address(addr, sender) # Memorize balances for tests uraiden_pre_balance = token_instance.call().balanceOf(uraiden_instance.address) sender_pre_balance = token_instance.call().balanceOf(sender) receiver_pre_balance = token_instance.call().balanceOf(receiver) txn_hash = uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance1, balance_msg_sig ) # Check channel info channel_info = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) # deposit assert channel_info[1] == deposit assert channel_info[2] == 0 assert channel_info[3] == 0 assert channel_info[4] == balance1 # Check token balances post withrawal uraiden_balance = uraiden_pre_balance - balance1 assert token_instance.call().balanceOf(uraiden_instance.address) == uraiden_balance assert token_instance.call().balanceOf(sender) == sender_pre_balance assert token_instance.call().balanceOf(receiver) == receiver_pre_balance + balance1 print_gas(txn_hash, 'withdraw') balance_message_hash = balance_proof_hash( receiver, open_block_number, balance2, 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, balance2, balance_msg_sig ) channel_info = uraiden_instance.call().getChannelInfo(sender, receiver, open_block_number) # deposit assert channel_info[1] == deposit assert channel_info[2] == 0 assert channel_info[3] == 0 assert channel_info[4] == balance2 # Check token balances post withrawal uraiden_balance = uraiden_pre_balance - deposit assert token_instance.call().balanceOf(uraiden_instance.address) == uraiden_balance assert token_instance.call().balanceOf(sender) == sender_pre_balance assert token_instance.call().balanceOf(receiver) == receiver_pre_balance + deposit print_gas(txn_hash, 'withdraw')
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()