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_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_close_by_receiver(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
channel_pre_close_tests(contract, channel)
current_deposit = get_current_deposit(contract, channel)
balance = current_deposit - 1
balance_msg = get_balance_message(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_msg, tester.k1)
balance_msg_sig_false, addr = sign.check(balance_msg, tester.k3)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': A
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number + 1, balance,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number, balance + 1,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig_false)
receiver_pre_balance = token.call().balanceOf(receiver)
sender_pre_balance = token.call().balanceOf(sender)
contract_pre_balance = token.call().balanceOf(contract.address)
print('--BALANCES', receiver_pre_balance, sender_pre_balance,
contract_pre_balance)
trxid = contract.transact({
'from': receiver
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
receiver_post_balance = receiver_pre_balance + balance
sender_post_balance = sender_pre_balance + (current_deposit - balance)
contract_post_balance = contract_pre_balance - current_deposit
assert token.call().balanceOf(receiver) == receiver_post_balance
assert token.call().balanceOf(sender) == sender_post_balance
assert token.call().balanceOf(contract.address) == contract_post_balance
channel_settle_tests(contract, channel)
print('----------------------------------')
print('GAS USED test_close_by_receiver', get_gas_used(chain, trxid))
print('----------------------------------')
def test_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_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 addr == A
assert 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, bytearray())
web3.testing.mine(30)
with pytest.raises(tester.TransactionFailed):
verified_address = ecverify_test_contract.call().verify(
balance_message_hash, bytearray(64))
web3.testing.mine(30)
with pytest.raises(tester.TransactionFailed):
verified_address = ecverify_test_contract.call().verify(
balance_message_hash, bytearray(66))
web3.testing.mine(30)
verified_address = ecverify_test_contract.call().verify(
balance_message_hash2, signed_message)
assert verified_address != A
verified_address = ecverify_test_contract.call().verify(
balance_message_hash, signed_message)
assert verified_address == A
verified_address_false = ecverify_test_contract.call().verify(
balance_message_hash, signed_message_false)
assert verified_address_false != A
assert 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 verified_address == signer
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 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 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_verifyBalanceProof(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 = sign.eth_signed_typed_data_message(
('address', ('uint', 32), ('uint', 192), 'address'),
('receiver', 'block_created', 'balance', 'contract'),
(receiver, block, balance, uraiden.address))
balance_msg_sig, signer = sign.check(message_hash, tester.k2)
assert signer == A
signature_address = uraiden.call().verifyBalanceProof(
receiver, block, balance, balance_msg_sig)
assert signature_address == signer
# Wrong receiver
signature_address = uraiden.call().verifyBalanceProof(
B, block, balance, balance_msg_sig)
assert signature_address != signer
# Wrong block
signature_address = uraiden.call().verifyBalanceProof(
receiver, 10, balance, balance_msg_sig)
assert signature_address != signer
# Wrong balance
signature_address = uraiden.call().verifyBalanceProof(
receiver, block, 20, balance_msg_sig)
assert signature_address != signer
def test_close_call(get_accounts, uraiden_instance, token_instance,
get_channel):
(sender, receiver, A) = get_accounts(3)
channel_deposit = 450
channel = get_channel(uraiden_instance, token_instance, channel_deposit,
sender, receiver)
(sender, receiver, open_block_number) = channel
balance = channel_deposit - 10
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)
# Cannot close what was not opened
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': sender
}).uncooperativeClose(A, open_block_number, balance, balance_msg_sig)
# Cannot close if arguments not correct
with pytest.raises(ValueError):
uraiden_instance.transact({
'from': sender
}).initChallengePeriod(receiver, open_block_number, balance)
with pytest.raises(ValueError):
uraiden_instance.transact({
'from': receiver
}).settleChannel(sender, receiver, open_block_number, balance)
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_verifyBalanceProof(web3, token_contract, channels_contract):
(A, B) = web3.eth.accounts[:2]
challenge_period = 5
supply = 10000 * 10**18
token = token_contract([supply, "CustomToken", "TKN", 18])
contract = channels_contract([token.address, challenge_period])
signer = '0x5601ea8445a5d96eeebf89a67c4199fbb7a43fbb'
receiver = '0x5601ea8445a5d96eeebf89a67c4199fbb7a43fbb'
block = 4804175
balance = 22000000000000000000
balance_msg_sig = '0x1803dfc1e597c08f0cc3f6e39fb109f6497c2b5321deb656f54567981889fddb49c82a33ecae2b1ae86f2fb50f0929cbad097502f8c04c7bfb8ae51883d3e1371b'
balance_msg_sig = bytes.fromhex(balance_msg_sig[2:])
signature_address = contract.call().verifyBalanceProof(
receiver, block, balance, balance_msg_sig)
assert signature_address == signer
balance_message_hash = balance_proof_hash(B, block, balance)
balance_msg_sig, addr = sign.check(balance_message_hash, tester.k0)
assert addr == A
signature_address = contract.call().verifyBalanceProof(
B, block, balance, balance_msg_sig)
assert signature_address == A
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_ecrecover_output(web3, ecverify_test_contract):
(A, B) = web3.eth.accounts[:2]
message = "daddydaddycool"
prefixed_message = sign.eth_message_prefixed(message)
hash_prefixed_message = sign.eth_message_hex(message)
signed_message, addr = sign.check(message, tester.k0)
# r = signed_message[:32];
# s = signed_message[32:64];
# v = int(binascii.hexlify(signed_message[64:65]), 16) # int(signed_message[64:65]);
r = bytes.fromhex(
'12d99ba7bd20ac17bac65bfd646146c1ddbeb607519db6e7935684334d891ed6')
s = bytes.fromhex(
'5d4ea3a13697c1d506f7bdb8cd672b944e2053d6d6bd87d4aa512fdc29ed9ae4')
v = 28
address = '0x5601Ea8445A5d96EEeBF89A67C4199FbB7a43Fbb'
with pytest.raises(tester.TransactionFailed):
ecverify_test_contract.call().verify_ecrecover_output(
hash_prefixed_message, r, s, 0)
web3.testing.mine(30)
with pytest.raises(tester.TransactionFailed):
ecverify_test_contract.call().verify_ecrecover_output(
hash_prefixed_message, r, bytearray(), v)
web3.testing.mine(30)
with pytest.raises(tester.TransactionFailed):
ecverify_test_contract.call().verify_ecrecover_output(
hash_prefixed_message, bytearray(), s, v)
web3.testing.mine(30)
verified_address = ecverify_test_contract.call().verify_ecrecover_output(
hash_prefixed_message, r, s, v)
def test_close_call(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
balance = channel_deposit - 10
balance_msg = get_balance_message(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_msg, tester.k1)
# Cannot close what was not opened
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': A
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': sender
}).uncooperativeClose(A, open_block_number, balance, balance_msg_sig)
# Cannot close if arguments not correct
with pytest.raises(ValueError):
contract.transact({
'from': sender
}).initChallengePeriod(receiver, open_block_number, balance)
with pytest.raises(ValueError):
contract.transact({
'from': receiver
}).settleChannel(sender, receiver, open_block_number, balance)
def test_extract_closing_signature(get_accounts, token_instance,
uraiden_instance):
(A, B) = get_accounts(2)
token = token_instance
uraiden = uraiden_instance
sender = '0x5601ea8445a5d96eeebf89a67c4199fbb7a43fbb'
block = 4804175
balance = 22000000000000000000
message_hash = closing_message_hash(sender, block, balance,
uraiden.address)
balance_msg_sig, signer = sign.check(message_hash, tester.k2)
assert signer == A
signature_address = uraiden.call().extractClosingSignature(
sender, block, balance, balance_msg_sig)
assert signature_address == signer
# Wrong sender
signature_address = uraiden.call().extractClosingSignature(
B, block, balance, balance_msg_sig)
assert signature_address != signer
# Wrong block
signature_address = uraiden.call().extractClosingSignature(
sender, 10, balance, balance_msg_sig)
assert signature_address != signer
# Wrong balance
signature_address = uraiden.call().extractClosingSignature(
sender, block, 20, balance_msg_sig)
assert signature_address != signer
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_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_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_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)
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_close_by_sender_challenge_settle_by_sender2(web3, chain, contract,
channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
current_deposit = get_current_deposit(contract, channel)
balance = 0
balance_msg = get_balance_message(receiver, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_msg, tester.k1)
receiver_pre_balance = token.call().balanceOf(receiver)
sender_pre_balance = token.call().balanceOf(sender)
contract_pre_balance = token.call().balanceOf(contract.address)
channel_pre_close_tests(contract, channel)
trxid1 = contract.transact({
'from': sender
}).uncooperativeClose(receiver, open_block_number, balance,
balance_msg_sig)
channel_data = contract.call().getChannelInfo(sender, receiver,
open_block_number)
assert channel_data[2] != 0 # settle_block_number
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).settle(receiver, open_block_number)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).settle(receiver, open_block_number)
web3.testing.mine(challenge_period + 1)
with pytest.raises(tester.TransactionFailed):
contract.transact({
'from': receiver
}).settle(receiver, open_block_number)
trxid2 = contract.transact({
'from': sender
}).settle(receiver, open_block_number)
receiver_post_balance = receiver_pre_balance + balance
sender_post_balance = sender_pre_balance + (current_deposit - balance)
contract_post_balance = contract_pre_balance - current_deposit
assert token.call().balanceOf(receiver) == receiver_post_balance
assert token.call().balanceOf(sender) == sender_post_balance
assert token.call().balanceOf(contract.address) == contract_post_balance
channel_settle_tests(contract, channel)
print('----------------------------------')
print('GAS USED test_close_by_sender_challenge_settle_by_sender2',
get_gas_used(chain, trxid1) + get_gas_used(chain, trxid2))
print('----------------------------------')
def test_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_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_sign(web3, ecverify_test_contract):
(A, B) = web3.eth.accounts[:2]
message = "daddydaddycool"
prefixed_message = sign.eth_message_prefixed(message)
signed_message, addr = sign.check(message, tester.k0)
signed_message_false, addr1 = sign.check(message, tester.k1)
assert addr == A
assert 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(
prefixed_message, bytearray())
web3.testing.mine(30)
with pytest.raises(tester.TransactionFailed):
verified_address = ecverify_test_contract.call().verify(
prefixed_message, bytearray(64))
web3.testing.mine(30)
with pytest.raises(tester.TransactionFailed):
verified_address = ecverify_test_contract.call().verify(
prefixed_message, bytearray(66))
web3.testing.mine(30)
verified_address = ecverify_test_contract.call().verify(
message, signed_message)
assert verified_address != A
verified_address = ecverify_test_contract.call().verify(
prefixed_message, signed_message)
assert verified_address == A
verified_address_false = ecverify_test_contract.call().verify(
prefixed_message, signed_message_false)
assert verified_address_false != A
assert verified_address_false == B
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_closing_signature(get_accounts, token_instance, uraiden_instance):
(A, B) = get_accounts(2)
token = token_instance
uraiden = uraiden_instance
sender = '0x5601Ea8445A5d96EEeBF89A67C4199FbB7a43Fbb'
block = 4804175
balance = 22000000000000000000
message_hash = closing_message_hash(sender, block, balance, uraiden.address)
balance_msg_sig, signer = sign.check(message_hash, tester.k2)
assert is_same_address(signer, A)
signature_address = uraiden.call().extractClosingSignature(
sender,
block,
balance,
balance_msg_sig
)
assert is_same_address(signature_address, signer)
# Wrong sender
signature_address = uraiden.call().extractClosingSignature(
B,
block,
balance,
balance_msg_sig
)
assert not is_same_address(signature_address, signer)
# Wrong block
signature_address = uraiden.call().extractClosingSignature(
sender,
10,
balance,
balance_msg_sig
)
assert not is_same_address(signature_address, signer)
# Wrong balance
signature_address = uraiden.call().extractClosingSignature(
sender,
block,
20,
balance_msg_sig
)
assert not is_same_address(signature_address, signer)
def test_close_by_sender(web3, chain, contract, channel):
(sender, receiver, open_block_number) = channel
(A) = web3.eth.accounts[3]
current_deposit = get_current_deposit(contract, channel)
balance = current_deposit - 1
balance_message_hash = balance_proof_hash(receiver, open_block_number, balance)
balance_message_hash_false_receiver = balance_proof_hash(A, open_block_number, balance)
balance_msg_sig, addr = sign.check(balance_message_hash, tester.k1)
balance_msg_sig_false_signer, addr = sign.check(balance_message_hash, tester.k3)
balance_msg_sig_false_receiver, addr = sign.check(balance_message_hash_false_receiver, tester.k3)
closing_sig, addr = sign.check(balance_message_hash, tester.k2)
closing_sig_false_signer, addr = sign.check(balance_message_hash, tester.k3)
closing_sig_false_receiver, addr = sign.check(balance_message_hash_false_receiver, tester.k2)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(A, open_block_number, balance, balance_msg_sig, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number - 3, balance, balance_msg_sig, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance + 5, balance_msg_sig, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig_false_signer, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig_false_receiver, closing_sig)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig_false_signer)
with pytest.raises(tester.TransactionFailed):
contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig_false_receiver)
receiver_pre_balance = token.call().balanceOf(receiver)
sender_pre_balance = token.call().balanceOf(sender)
contract_pre_balance = token.call().balanceOf(contract.address)
channel_pre_close_tests(contract, channel)
trxid = contract.transact({'from': sender}).cooperativeClose(receiver, open_block_number, balance, balance_msg_sig, closing_sig)
receiver_post_balance = receiver_pre_balance + balance
sender_post_balance = sender_pre_balance + (current_deposit - balance)
contract_post_balance = contract_pre_balance - current_deposit
assert token.call().balanceOf(receiver) == receiver_post_balance
assert token.call().balanceOf(sender) == sender_post_balance
assert token.call().balanceOf(contract.address) == contract_post_balance
channel_settle_tests(contract, channel)
print('----------------------------------')
print('GAS USED test_close_by_sender', get_gas_used(chain, trxid))
print('----------------------------------')
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_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_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 getTokens(**kwargs):
project = Project()
# print(kwargs)
chain_name = kwargs['chain']
owner = kwargs['owner']
challenge_period = kwargs['challenge_period']
supply = kwargs['supply']
senders = kwargs['senders']
sender_addresses = kwargs['sender_addresses']
token_name = kwargs['token_name']
token_decimals = kwargs['token_decimals']
token_symbol = kwargs['token_symbol']
token_address = kwargs['token_address']
if sender_addresses:
sender_addresses = sender_addresses.split(',')
else:
sender_addresses = []
supply *= 10**(token_decimals)
txn_wait = 250
event_wait = 50
if chain_name == 'rinkeby':
txn_wait = 500
event_wait = 500
print(
'''Make sure {} chain is running, you can connect to it and it is synced,
or you'll get timeout'''.format(chain_name))
with project.get_chain(chain_name) as chain:
web3 = chain.web3
owner = owner or web3.eth.accounts[0]
print('Web3 provider is', web3.currentProvider)
token = chain.provider.get_contract_factory('CustomToken')
if not token_address:
txhash = token.deploy(
args=[supply, token_name, token_symbol, token_decimals],
transaction={'from': owner})
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
token_address = receipt['contractAddress']
print(token_name, ' address is', token_address)
channel_factory = chain.provider.get_contract_factory(
'RaidenMicroTransferChannels')
txhash = channel_factory.deploy(args=[token_address, challenge_period])
print('RaidenMicroTransferChannels arguments', token_address,
challenge_period)
padded_token_address = pad_left(remove_0x_prefix(token_address), 64,
'0')
print('RaidenMicroTransferChannels abi encoded arguments:',
encode_hex(pack(padded_token_address, challenge_period)))
receipt = check_succesful_tx(chain.web3, txhash, txn_wait)
cf_address = receipt['contractAddress']
print('RaidenMicroTransferChannels address is', cf_address)
if senders > 0 or len(sender_addresses) > 0:
priv_keys = []
addresses = []
token_assign = int(supply / (len(sender_addresses) + senders))
# we cannot retrieve private keys from configured chains
# therefore: create 5 wallets (sample addresses with private keys)
# store in separate arrays
for i in range(senders - 1):
priv_key, address = createWallet()
priv_keys.append(priv_key)
addresses.append('0x' + address)
# send tokens to each new wallet
for sender in addresses:
token(token_address).transact({
'from': owner
}).transfer(sender, token_assign)
# also send tokens to sender addresses
for sender in sender_addresses:
token(token_address).transact({
'from': owner
}).transfer(sender, token_assign)
print('Senders have each been issued', token_assign, ' tokens')
# check if it works:
# 1. get message balance hash for address[0]
balance_msg = "Receiver: " + addresses[
0] + ", Balance: 10000, Channel ID: 100"
# 2. sign the hash with private key corresponding to address[0]
balance_msg_sig, addr = sign.check(
balance_msg,
binascii.unhexlify(remove_0x_prefix(priv_keys[0])))
# 3. check if ECVerify and ec_recovered address are equal
ec_recovered_addr = channel_factory(
cf_address).call().verifyBalanceProof(addresses[0], 100, 10000,
balance_msg_sig)
print('EC_RECOVERED_ADDR:', ec_recovered_addr)
print('FIRST WALLET ADDR:', addresses[0])
assert ec_recovered_addr == addresses[0]
print('Wait for confirmation...')
transfer_filter = token.on('Transfer')
wait(transfer_filter, event_wait)
print('BALANCE:',
token(token_address).call().balanceOf(addresses[0]))
assert token(token_address).call().balanceOf(addresses[0]) > 0
# return arrays with generated wallets
# (private keys first, then addresses, so that priv_key[0] <-> address[0]
return (priv_keys, addresses, token(token_address))
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_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' # noqa
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_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_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_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')
