def test_three():
hash_0 = b'a' * 32
hash_1 = b'b' * 32
hash_2 = b'c' * 32
leaves = [hash_0, hash_1, hash_2]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
hash_01 = (b'me\xef\x9c\xa9=5\x16\xa4\xd3\x8a\xb7\xd9\x89\xc2\xb5\x00'
b'\xe2\xfc\x89\xcc\xdc\xf8x\xf9\xc4m\xaa\xf6\xad\r[')
assert sha3(hash_0 + hash_1) == hash_01
calculated_root = sha3(hash_2 + hash_01)
proof0 = compute_merkleproof_for(tree, hash_0)
proof1 = compute_merkleproof_for(tree, hash_1)
proof2 = compute_merkleproof_for(tree, hash_2)
assert proof0 == [hash_1, hash_2]
assert root == calculated_root
assert validate_proof(proof0, root, hash_0)
assert proof1 == [hash_0, hash_2]
assert root == calculated_root
assert validate_proof(proof1, root, hash_1)
# with an odd number of values, the last value wont appear by itself in the
# proof since it isn't hashed with another value
assert proof2 == [sha3(hash_0 + hash_1)]
assert root == calculated_root
assert validate_proof(proof2, root, hash_2)
def test_three():
hash_0 = b'a' * 32
hash_1 = b'b' * 32
hash_2 = b'c' * 32
leaves = [hash_0, hash_1, hash_2]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
hash_01 = (
b'me\xef\x9c\xa9=5\x16\xa4\xd3\x8a\xb7\xd9\x89\xc2\xb5\x00'
b'\xe2\xfc\x89\xcc\xdc\xf8x\xf9\xc4m\xaa\xf6\xad\r['
)
assert sha3(hash_0 + hash_1) == hash_01
calculated_root = sha3(hash_2 + hash_01)
proof0 = compute_merkleproof_for(tree, hash_0)
proof1 = compute_merkleproof_for(tree, hash_1)
proof2 = compute_merkleproof_for(tree, hash_2)
assert proof0 == [hash_1, hash_2]
assert root == calculated_root
assert validate_proof(proof0, root, hash_0)
assert proof1 == [hash_0, hash_2]
assert root == calculated_root
assert validate_proof(proof1, root, hash_1)
# with an odd number of values, the last value wont appear by itself in the
# proof since it isn't hashed with another value
assert proof2 == [sha3(hash_0 + hash_1)]
assert root == calculated_root
assert validate_proof(proof2, root, hash_2)
def test_two():
hash_0 = b'a' * 32
hash_1 = b'b' * 32
leaves = [hash_0, hash_1]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
proof0 = compute_merkleproof_for(tree, hash_0)
proof1 = compute_merkleproof_for(tree, hash_1)
assert proof0 == [hash_1]
assert root == sha3(hash_0 + hash_1)
assert validate_proof(proof0, root, hash_0)
assert proof1 == [hash_0]
assert root == sha3(hash_0 + hash_1)
assert validate_proof(proof1, root, hash_1)
def test_two():
hash_0 = b'a' * 32
hash_1 = b'b' * 32
leaves = [hash_0, hash_1]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
proof0 = compute_merkleproof_for(tree, hash_0)
proof1 = compute_merkleproof_for(tree, hash_1)
assert proof0 == [hash_1]
assert root == sha3(hash_0 + hash_1)
assert validate_proof(proof0, root, hash_0)
assert proof1 == [hash_0]
assert root == sha3(hash_0 + hash_1)
assert validate_proof(proof1, root, hash_1)
def test_one():
hash_0 = b'a' * 32
leaves = [hash_0]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
proof = compute_merkleproof_for(tree, hash_0)
assert proof == []
assert root == hash_0
assert validate_proof(proof, root, hash_0) is True
def test_one():
hash_0 = b'a' * 32
leaves = [hash_0]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
proof = compute_merkleproof_for(tree, hash_0)
assert proof == []
assert root == hash_0
assert validate_proof(proof, root, hash_0) is True
def test_many(tree_up_to=10):
for number_of_leaves in range(1, tree_up_to): # skipping the empty tree
leaves = [sha3(str(value)) for value in range(number_of_leaves)]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
for value in leaves:
proof = compute_merkleproof_for(tree, value)
assert validate_proof(proof, root, value)
reversed_tree = MerkleTreeState(compute_layers(reversed(leaves)))
assert root == merkleroot(reversed_tree)
def test_many(tree_up_to=10):
for number_of_leaves in range(1, tree_up_to): # skipping the empty tree
leaves = [
sha3(str(value).encode())
for value in range(number_of_leaves)
]
layers = compute_layers(leaves)
tree = MerkleTreeState(layers)
root = merkleroot(tree)
for value in leaves:
proof = compute_merkleproof_for(tree, value)
assert validate_proof(proof, root, value)
reversed_tree = MerkleTreeState(compute_layers(reversed(leaves)))
assert root == merkleroot(reversed_tree)
def test_unlock(raiden_network, token_addresses, deposit):
"""Unlock can be called on a closed channel."""
alice_app, bob_app = raiden_network
registry_address = alice_app.raiden.default_registry.address
token_address = token_addresses[0]
token_proxy = alice_app.raiden.chain.token(token_address)
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(alice_app),
alice_app.raiden.default_registry.address,
token_address,
)
alice_initial_balance = token_proxy.balance_of(alice_app.raiden.address)
bob_initial_balance = token_proxy.balance_of(bob_app.raiden.address)
alice_to_bob_amount = 10
identifier = 1
secret = pending_mediated_transfer(
raiden_network,
token_network_identifier,
alice_to_bob_amount,
identifier,
)
secrethash = sha3(secret)
# This is the current state of the protocol:
#
# A -> B LockedTransfer
# B -> A SecretRequest
# - protocol didn't continue
alice_bob_channel = get_channelstate(alice_app, bob_app, token_network_identifier)
bob_alice_channel = get_channelstate(bob_app, alice_app, token_network_identifier)
lock = channel.get_lock(alice_bob_channel.our_state, secrethash)
assert lock
assert_synched_channel_state(
token_network_identifier,
alice_app, deposit, [lock],
bob_app, deposit, [],
)
# get proof, that locked transfermessage was in merkle tree, with locked.root
unlock_proof = channel.compute_proof_for_lock(
alice_bob_channel.our_state,
secret,
lock,
)
assert validate_proof(
unlock_proof.merkle_proof,
merkleroot(bob_alice_channel.partner_state.merkletree),
sha3(lock.encoded),
)
assert unlock_proof.lock_encoded == lock.encoded
assert unlock_proof.secret == secret
# A ChannelClose event will be generated, this will be polled by both apps
# and each must start a task for calling settle
RaidenAPI(bob_app.raiden).channel_close(
registry_address,
token_address,
alice_app.raiden.address,
)
# Unlock will not be called because the secret was not revealed
assert lock.expiration > alice_app.raiden.chain.block_number()
assert lock.secrethash == sha3(secret)
nettingchannel_proxy = bob_app.raiden.chain.netting_channel(
bob_alice_channel.identifier,
)
nettingchannel_proxy.unlock(unlock_proof)
waiting.wait_for_settle(
alice_app.raiden,
registry_address,
token_address,
[alice_bob_channel.identifier],
alice_app.raiden.alarm.wait_time,
)
alice_bob_channel = get_channelstate(alice_app, bob_app, token_network_identifier)
bob_alice_channel = get_channelstate(bob_app, alice_app, token_network_identifier)
alice_netted_balance = alice_initial_balance + deposit - alice_to_bob_amount
bob_netted_balance = bob_initial_balance + deposit + alice_to_bob_amount
assert token_proxy.balance_of(alice_app.raiden.address) == alice_netted_balance
assert token_proxy.balance_of(bob_app.raiden.address) == bob_netted_balance
# Now let's query the WAL to see if the state changes were logged as expected
state_changes = alice_app.raiden.wal.storage.get_statechanges_by_identifier(
from_identifier=0,
to_identifier='latest',
)
alice_bob_channel = get_channelstate(alice_app, bob_app, token_network_identifier)
bob_alice_channel = get_channelstate(bob_app, alice_app, token_network_identifier)
assert must_contain_entry(state_changes, ContractReceiveChannelUnlock, {
'payment_network_identifier': registry_address,
'token_address': token_address,
'channel_identifier': alice_bob_channel.identifier,
'secrethash': secrethash,
'secret': secret,
'receiver': bob_app.raiden.address,
})
def test_settlement(raiden_network, settle_timeout, reveal_timeout):
alice_app, bob_app = raiden_network # pylint: disable=unbalanced-tuple-unpacking
setup_messages_cb()
alice_graph = list(alice_app.raiden.token_to_channelgraph.values())[0]
bob_graph = list(bob_app.raiden.token_to_channelgraph.values())[0]
assert alice_graph.token_address == bob_graph.token_address
alice_bob_channel = alice_graph.partneraddress_to_channel[bob_app.raiden.address]
bob_alice_channel = bob_graph.partneraddress_to_channel[alice_app.raiden.address]
alice_deposit = alice_bob_channel.balance
bob_deposit = bob_alice_channel.balance
token = alice_app.raiden.chain.token(alice_bob_channel.token_address)
alice_balance = token.balance_of(alice_app.raiden.address)
bob_balance = token.balance_of(bob_app.raiden.address)
alice_chain = alice_app.raiden.chain
alice_to_bob_amount = 10
expiration = alice_app.raiden.chain.block_number() + reveal_timeout + 1
secret = b'secretsecretsecretsecretsecretse'
hashlock = sha3(secret)
assert bob_app.raiden.address in alice_graph.partneraddress_to_channel
nettingaddress0 = alice_bob_channel.external_state.netting_channel.address
nettingaddress1 = bob_alice_channel.external_state.netting_channel.address
assert nettingaddress0 == nettingaddress1
identifier = 1
fee = 0
transfermessage = alice_bob_channel.create_mediatedtransfer(
alice_app.raiden.address,
bob_app.raiden.address,
fee,
alice_to_bob_amount,
identifier,
expiration,
hashlock,
)
alice_app.raiden.sign(transfermessage)
alice_bob_channel.register_transfer(
alice_app.raiden.get_block_number(),
transfermessage,
)
bob_alice_channel.register_transfer(
bob_app.raiden.get_block_number(),
transfermessage,
)
assert_synched_channels(
alice_bob_channel, alice_deposit, [],
bob_alice_channel, bob_deposit, [transfermessage.lock],
)
# At this point we are assuming the following:
#
# A -> B MediatedTransfer
# B -> A SecretRequest
# A -> B RevealSecret
# - protocol didn't continue
#
# B knowns the secret but doesn't have an updated balance proof, B needs to
# call settle.
# get proof, that locked transfermessage was in merkle tree, with locked.root
lock = bob_alice_channel.partner_state.get_lock_by_hashlock(hashlock)
assert sha3(secret) == hashlock
unlock_proof = bob_alice_channel.partner_state.compute_proof_for_lock(secret, lock)
root = merkleroot(bob_alice_channel.partner_state.merkletree)
assert validate_proof(
unlock_proof.merkle_proof,
root,
sha3(transfermessage.lock.as_bytes),
)
assert unlock_proof.lock_encoded == transfermessage.lock.as_bytes
assert unlock_proof.secret == secret
# a ChannelClose event will be generated, this will be polled by both apps
# and each must start a task for calling settle
balance_proof = transfermessage.to_balanceproof()
bob_alice_channel.external_state.close(balance_proof)
wait_until_block(alice_chain, alice_chain.block_number() + 1)
assert alice_bob_channel.external_state.close_event.wait(timeout=15)
assert bob_alice_channel.external_state.close_event.wait(timeout=15)
assert alice_bob_channel.external_state.closed_block != 0
assert bob_alice_channel.external_state.closed_block != 0
assert alice_bob_channel.external_state.settled_block == 0
assert bob_alice_channel.external_state.settled_block == 0
# unlock will not be called by Channel.channel_closed because we did not
# register the secret
assert lock.expiration > alice_app.raiden.chain.block_number()
assert lock.hashlock == sha3(secret)
bob_alice_channel.external_state.netting_channel.withdraw([unlock_proof])
settle_expiration = alice_chain.block_number() + settle_timeout + 2
wait_until_block(alice_chain, settle_expiration)
assert alice_bob_channel.external_state.settle_event.wait(timeout=15)
assert bob_alice_channel.external_state.settle_event.wait(timeout=15)
# settle must be called by the apps triggered by the ChannelClose event,
# and the channels must update it's state based on the ChannelSettled event
assert alice_bob_channel.external_state.settled_block != 0
assert bob_alice_channel.external_state.settled_block != 0
address0 = alice_app.raiden.address
address1 = bob_app.raiden.address
alice_netted_balance = alice_balance + alice_deposit - alice_to_bob_amount
bob_netted_balance = bob_balance + bob_deposit + alice_to_bob_amount
assert token.balance_of(address0) == alice_netted_balance
assert token.balance_of(address1) == bob_netted_balance
# Now let's query the WAL to see if the state changes were logged as expected
state_changes = [
change[1] for change in get_all_state_changes(alice_app.raiden.transaction_log)
if not isinstance(change[1], Block)
]
assert must_contain_entry(state_changes, ContractReceiveClosed, {
'channel_address': nettingaddress0,
'closing_address': bob_app.raiden.address,
'block_number': alice_bob_channel.external_state.closed_block,
})
assert must_contain_entry(state_changes, ReceiveSecretReveal, {
'secret': secret,
'sender': bob_app.raiden.address,
})
assert must_contain_entry(state_changes, ContractReceiveWithdraw, {
'channel_address': nettingaddress0,
'secret': secret,
'receiver': bob_app.raiden.address,
})
assert must_contain_entry(state_changes, ContractReceiveSettled, {
'channel_address': nettingaddress0,
'block_number': bob_alice_channel.external_state.settled_block,
})
def test_settlement(raiden_network, settle_timeout, reveal_timeout):
alice_app, bob_app = raiden_network # pylint: disable=unbalanced-tuple-unpacking
setup_messages_cb()
alice_graph = list(alice_app.raiden.token_to_channelgraph.values())[0]
bob_graph = list(bob_app.raiden.token_to_channelgraph.values())[0]
assert alice_graph.token_address == bob_graph.token_address
alice_bob_channel = alice_graph.partneraddress_to_channel[
bob_app.raiden.address]
bob_alice_channel = bob_graph.partneraddress_to_channel[
alice_app.raiden.address]
alice_deposit = alice_bob_channel.balance
bob_deposit = bob_alice_channel.balance
token = alice_app.raiden.chain.token(alice_bob_channel.token_address)
alice_balance = token.balance_of(alice_app.raiden.address)
bob_balance = token.balance_of(bob_app.raiden.address)
alice_chain = alice_app.raiden.chain
alice_to_bob_amount = 10
expiration = alice_app.raiden.chain.block_number() + reveal_timeout + 1
secret = b'secretsecretsecretsecretsecretse'
hashlock = sha3(secret)
assert bob_app.raiden.address in alice_graph.partneraddress_to_channel
nettingaddress0 = alice_bob_channel.external_state.netting_channel.address
nettingaddress1 = bob_alice_channel.external_state.netting_channel.address
assert nettingaddress0 == nettingaddress1
identifier = 1
fee = 0
transfermessage = alice_bob_channel.create_mediatedtransfer(
alice_app.raiden.address,
bob_app.raiden.address,
fee,
alice_to_bob_amount,
identifier,
expiration,
hashlock,
)
alice_app.raiden.sign(transfermessage)
alice_bob_channel.register_transfer(
alice_app.raiden.get_block_number(),
transfermessage,
)
bob_alice_channel.register_transfer(
bob_app.raiden.get_block_number(),
transfermessage,
)
assert_synched_channels(
alice_bob_channel,
alice_deposit,
[],
bob_alice_channel,
bob_deposit,
[transfermessage.lock],
)
# At this point we are assuming the following:
#
# A -> B MediatedTransfer
# B -> A SecretRequest
# A -> B RevealSecret
# - protocol didn't continue
#
# B knowns the secret but doesn't have an updated balance proof, B needs to
# call settle.
# get proof, that locked transfermessage was in merkle tree, with locked.root
lock = bob_alice_channel.partner_state.get_lock_by_hashlock(hashlock)
assert sha3(secret) == hashlock
unlock_proof = bob_alice_channel.partner_state.compute_proof_for_lock(
secret, lock)
root = merkleroot(bob_alice_channel.partner_state.merkletree)
assert validate_proof(
unlock_proof.merkle_proof,
root,
sha3(transfermessage.lock.as_bytes),
)
assert unlock_proof.lock_encoded == transfermessage.lock.as_bytes
assert unlock_proof.secret == secret
# a ChannelClose event will be generated, this will be polled by both apps
# and each must start a task for calling settle
balance_proof = transfermessage.to_balanceproof()
bob_alice_channel.external_state.close(balance_proof)
wait_until_block(alice_chain, alice_chain.block_number() + 1)
assert alice_bob_channel.external_state.close_event.wait(timeout=15)
assert bob_alice_channel.external_state.close_event.wait(timeout=15)
assert alice_bob_channel.external_state.closed_block != 0
assert bob_alice_channel.external_state.closed_block != 0
assert alice_bob_channel.external_state.settled_block == 0
assert bob_alice_channel.external_state.settled_block == 0
# unlock will not be called by Channel.channel_closed because we did not
# register the secret
assert lock.expiration > alice_app.raiden.chain.block_number()
assert lock.hashlock == sha3(secret)
bob_alice_channel.external_state.netting_channel.withdraw([unlock_proof])
settle_expiration = alice_chain.block_number() + settle_timeout + 2
wait_until_block(alice_chain, settle_expiration)
assert alice_bob_channel.external_state.settle_event.wait(timeout=15)
assert bob_alice_channel.external_state.settle_event.wait(timeout=15)
# settle must be called by the apps triggered by the ChannelClose event,
# and the channels must update it's state based on the ChannelSettled event
assert alice_bob_channel.external_state.settled_block != 0
assert bob_alice_channel.external_state.settled_block != 0
address0 = alice_app.raiden.address
address1 = bob_app.raiden.address
alice_netted_balance = alice_balance + alice_deposit - alice_to_bob_amount
bob_netted_balance = bob_balance + bob_deposit + alice_to_bob_amount
assert token.balance_of(address0) == alice_netted_balance
assert token.balance_of(address1) == bob_netted_balance
# Now let's query the WAL to see if the state changes were logged as expected
state_changes = [
change[1]
for change in get_all_state_changes(alice_app.raiden.transaction_log)
if not isinstance(change[1], Block)
]
assert must_contain_entry(
state_changes, ContractReceiveClosed, {
'channel_address': nettingaddress0,
'closing_address': bob_app.raiden.address,
'block_number': alice_bob_channel.external_state.closed_block,
})
assert must_contain_entry(state_changes, ReceiveSecretReveal, {
'secret': secret,
'sender': bob_app.raiden.address,
})
assert must_contain_entry(
state_changes, ContractReceiveWithdraw, {
'channel_address': nettingaddress0,
'secret': secret,
'receiver': bob_app.raiden.address,
})
assert must_contain_entry(
state_changes, ContractReceiveSettled, {
'channel_address': nettingaddress0,
'block_number': bob_alice_channel.external_state.settled_block,
})
