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_extract_balance_proof_signature(get_accounts, token_instance, uraiden_instance): (A, B) = get_accounts(2) token = token_instance uraiden = uraiden_instance receiver = '0x5601ea8445a5d96eeebf89a67c4199fbb7a43fbb' block = 4804175 balance = 22000000000000000000 message_hash = balance_proof_hash(receiver, block, balance, uraiden.address) balance_msg_sig, signer = sign.check(message_hash, tester.k2) assert signer == A signature_address = uraiden.call().extractBalanceProofSignature( receiver, block, balance, balance_msg_sig) assert signature_address == signer # Wrong receiver signature_address = uraiden.call().extractBalanceProofSignature( B, block, balance, balance_msg_sig) assert signature_address != signer # Wrong block signature_address = uraiden.call().extractBalanceProofSignature( receiver, 10, balance, balance_msg_sig) assert signature_address != signer # Wrong balance signature_address = uraiden.call().extractBalanceProofSignature( receiver, block, 20, balance_msg_sig) assert signature_address != signer
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_ecrecover_output(web3, ecverify_test_contract): (A, B) = web3.eth.accounts[:2] block = 4804175 balance = 22000000000000000000 balance_message_hash = balance_proof_hash(B, block, balance, ecverify_test_contract.address) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k0) assert is_same_address(addr, A) r = bytes.fromhex('12d99ba7bd20ac17bac65bfd646146c1ddbeb607519db6e7935684334d891ed6') s = bytes.fromhex('5d4ea3a13697c1d506f7bdb8cd672b944e2053d6d6bd87d4aa512fdc29ed9ae4') v = 28 with pytest.raises(tester.TransactionFailed): ecverify_test_contract.call().verify_ecrecover_output(balance_message_hash, r, s, 0) # We have to simulate mining because ecrecover consumes a lot of gas for precompiled contracts # on private chains. web3.testing.mine(30) ecverify_test_contract.call().verify_ecrecover_output( balance_message_hash, r, s, v )
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_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_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_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_ecrecover_output(web3, ecverify_test_contract): (A, B) = web3.eth.accounts[:2] block = 4804175 balance = 22000000000000000000 balance_message_hash = balance_proof_hash(B, block, balance, ecverify_test_contract.address) balance_msg_sig, addr = sign.check(balance_message_hash, tester.k0) assert addr == A r = bytes.fromhex( '12d99ba7bd20ac17bac65bfd646146c1ddbeb607519db6e7935684334d891ed6') s = bytes.fromhex( '5d4ea3a13697c1d506f7bdb8cd672b944e2053d6d6bd87d4aa512fdc29ed9ae4') v = 28 with pytest.raises(tester.TransactionFailed): ecverify_test_contract.call().verify_ecrecover_output( balance_message_hash, r, s, 0) # We have to simulate mining because ecrecover consumes a lot of gas for precompiled contracts # on private chains. web3.testing.mine(30) with pytest.raises(tester.TransactionFailed): ecverify_test_contract.call().verify_ecrecover_output( balance_message_hash, r, bytearray(), v) web3.testing.mine(30) with pytest.raises(tester.TransactionFailed): ecverify_test_contract.call().verify_ecrecover_output( balance_message_hash, bytearray(), s, v) web3.testing.mine(30) ecverify_test_contract.call().verify_ecrecover_output( balance_message_hash, r, s, v)
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_balance_big( channel_params, get_accounts, uraiden_instance, get_channel): (sender, receiver, open_block_number) = get_channel()[:3] balance_ok = channel_params['deposit'] balance_big = channel_params['deposit'] + 1 balance_message_hash_big = balance_proof_hash( receiver, open_block_number, balance_big, uraiden_instance.address ) balance_msg_sig_big, addr = sign.check(balance_message_hash_big, tester.k2) assert is_same_address(addr, sender) balance_message_hash = balance_proof_hash( receiver, open_block_number, balance_ok, 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": receiver}).withdraw( open_block_number, balance_big, balance_msg_sig_big ) uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance_ok, balance_msg_sig )
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 get(uraiden=None, token=None, deposit=None, sender=None, receiver=None, contract_type=None): deposit = deposit or channel_params['deposit'] contract_type = contract_type or channel_params['type'] balance = channel_params['balance'] uraiden = uraiden or uraiden_instance token = token or token_instance if not sender: (sender, receiver) = get_accounts(2) # Supply accounts with tokens token.transact({"from": owner}).transfer(sender, deposit + 500) token.transact({"from": owner}).transfer(receiver, 100) # Create channel (ERC20 or ERC223 logic) if contract_type == '20': token.transact({"from": sender}).approve( uraiden.address, deposit ) txn_hash = uraiden.transact({"from": sender}).createChannel( receiver, deposit ) else: txdata = bytes.fromhex(sender[2:] + receiver[2:]) txn_hash = token.transact({"from": sender}).transfer( uraiden.address, deposit, txdata ) open_block_number = get_block(txn_hash) 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) closing_msg_hash = closing_message_hash( sender, open_block_number, balance, uraiden_instance.address ) closing_sig, addr = sign.check(closing_msg_hash, tester.k3) return (sender, receiver, open_block_number, balance_msg_sig, closing_sig)
def get(uraiden=None, token=None, deposit=None, sender=None, receiver=None, contract_type=None): deposit = deposit or channel_params['deposit'] contract_type = contract_type or channel_params['type'] balance = channel_params['balance'] uraiden = uraiden or uraiden_instance token = token or token_instance if not sender: (sender, receiver) = get_accounts(2) # Supply accounts with tokens token.transact({"from": owner}).transfer(sender, deposit + 500) token.transact({"from": owner}).transfer(receiver, 100) # Create channel (ERC20 or ERC223 logic) if contract_type == '20': token.transact({"from": sender}).approve( uraiden.address, deposit ) txn_hash = uraiden.transact({"from": sender}).createChannelERC20( receiver, deposit ) else: txdata = bytes.fromhex(receiver[2:].zfill(40)) txn_hash = token.transact({"from": sender}).transfer( uraiden.address, deposit, txdata ) open_block_number = get_block(txn_hash) 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) closing_msg_hash = closing_message_hash( sender, open_block_number, balance, uraiden_instance.address ) closing_sig, addr = sign.check(closing_msg_hash, tester.k3) return (sender, receiver, open_block_number, balance_msg_sig, closing_sig)
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_extract_balance_proof_signature(get_accounts, token_instance, uraiden_instance): (A, B) = get_accounts(2) token = token_instance uraiden = uraiden_instance receiver = '0x5601Ea8445A5d96EEeBF89A67C4199FbB7a43Fbb' block = 4804175 balance = 22000000000000000000 message_hash = balance_proof_hash(receiver, block, balance, uraiden.address) balance_msg_sig, signer = sign.check(message_hash, tester.k2) assert is_same_address(signer, A) signature_address = uraiden.call().extractBalanceProofSignature( receiver, block, balance, balance_msg_sig ) assert is_same_address(signature_address, signer) # Wrong receiver signature_address = uraiden.call().extractBalanceProofSignature( B, block, balance, balance_msg_sig ) assert not is_same_address(signature_address, signer) # Wrong block signature_address = uraiden.call().extractBalanceProofSignature( receiver, 10, balance, balance_msg_sig ) assert not is_same_address(signature_address, signer) # Wrong balance signature_address = uraiden.call().extractBalanceProofSignature( receiver, block, 20, balance_msg_sig ) assert not is_same_address(signature_address, signer)
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_message_hash = balance_proof_hash(receiver, open_block_number, balance) balance_msg_sig, addr = sign.check(balance_message_hash, 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_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)
def test_close_call(web3, chain, contract, channel): (sender, receiver, open_block_number) = channel (A) = web3.eth.accounts[3] balance = channel_deposit - 10 balance_message_hash = balance_proof_hash(receiver, open_block_number, balance) balance_msg_sig, addr = sign.check(balance_message_hash, 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_after_withdraw( 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_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) # Withdraw some tokens txn_hash = uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance1, balance_msg_sig1 ) # Cooperatively close the channel 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) closing_msg_hash = closing_message_hash( sender, open_block_number, balance2, uraiden_instance.address ) closing_sig, addr = sign.check(closing_msg_hash, tester.k3) # 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) uraiden_instance.transact({"from": receiver}).cooperativeClose( receiver, open_block_number, balance2, balance_msg_sig, closing_sig ) # Check post closing balances receiver_post_balance = receiver_pre_balance + (balance2 - balance1) sender_post_balance = sender_pre_balance + (deposit - balance2) uraiden_post_balance = uraiden_pre_balance - (balance2 - balance1) 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) == uraiden_post_balance
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 )
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_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_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_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_sign(web3, ecverify_test_contract): (A, B) = web3.eth.accounts[:2] block = 4804175 balance = 22000000000000000000 balance_message_hash = balance_proof_hash(B, block, balance, ecverify_test_contract.address) balance_message_hash2 = balance_proof_hash(B, block, balance + 1000, ecverify_test_contract.address) signed_message, addr = sign.check(balance_message_hash, tester.k0) signed_message_false, addr1 = sign.check(balance_message_hash, tester.k1) assert is_same_address(addr, A) assert is_same_address(addr1, B) assert len(signed_message) == 65 assert len(signed_message_false) == 65 with pytest.raises(tester.TransactionFailed): verified_address = ecverify_test_contract.call().verify( balance_message_hash, encode_hex(bytearray()) ) web3.testing.mine(30) with pytest.raises(tester.TransactionFailed): verified_address = ecverify_test_contract.call().verify( balance_message_hash, encode_hex(bytearray(64)) ) web3.testing.mine(30) with pytest.raises(tester.TransactionFailed): verified_address = ecverify_test_contract.call().verify( balance_message_hash, encode_hex(bytearray(66)) ) web3.testing.mine(30) verified_address = ecverify_test_contract.call().verify( balance_message_hash2, signed_message ) assert not is_same_address(verified_address, A) verified_address = ecverify_test_contract.call().verify( balance_message_hash, signed_message ) assert is_same_address(verified_address, A) verified_address_false = ecverify_test_contract.call().verify( balance_message_hash, signed_message_false ) assert not is_same_address(verified_address_false, A) assert is_same_address(verified_address_false, B) signer = '0x5601Ea8445A5d96EEeBF89A67C4199FbB7a43Fbb' value = 1000 value2 = 2000 _address = '0x5601Ea8445A5d96EEeBF89A67C4199FbB7a43Fbb' signed_message = '0x0adc437691e266072e9aa1763329062a6b2fa1d7f94034f1b1e691218fe9fd285f4f20132fa00230f591571a3575456bb382040e02e93ff0f32544907748a9821c' signed_message = bytes.fromhex(signed_message[2:]) verified_address = ecverify_test_contract.call().verifyEthSignedTypedData( _address, value, value2, signed_message ) assert is_same_address(verified_address, signer)
def test_close_after_withdraw( 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_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) # Withdraw some tokens txn_hash = uraiden_instance.transact({"from": receiver}).withdraw( open_block_number, balance1, balance_msg_sig1 ) assert txn_hash is not None # Cooperatively close the channel 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) closing_msg_hash = closing_message_hash( sender, open_block_number, balance2, uraiden_instance.address ) closing_sig, addr = sign.check(closing_msg_hash, tester.k3) # 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) uraiden_instance.transact({"from": receiver}).cooperativeClose( receiver, open_block_number, balance2, balance_msg_sig, closing_sig ) # Check post closing balances receiver_post_balance = receiver_pre_balance + (balance2 - balance1) sender_post_balance = sender_pre_balance + (deposit - balance2) uraiden_post_balance = uraiden_pre_balance - (balance2 - balance1) 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) == uraiden_post_balance
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')