def test_secret(iterations=ITERATIONS):
identifier = 1
secret = HASH
msg = Secret(
identifier,
secret
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('Secret', msg, iterations=iterations)
def test_secret(iterations=ITERATIONS):
identifier = 1
secret = HASH
amount = 1
msg = Secret(
identifier,
secret,
amount,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('Secret', msg, iterations=iterations)
def test_secret(iterations=ITERATIONS):
identifier = 1
nonce = 1
channel = HASH
transferred_amount = 1
secret = HASH
locksroot = ''
msg = Secret(
identifier,
nonce,
channel,
transferred_amount,
locksroot,
secret,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('Secret', msg, iterations=iterations)
def test_secret(iterations=ITERATIONS):
identifier = 1
nonce = 1
channel = HASH
transferred_amount = 1
secret = HASH
locksroot = ''
msg = Secret(
identifier,
nonce,
channel,
transferred_amount,
locksroot,
secret,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('Secret', msg, iterations=iterations)
def test_interwoven_transfers():
"""Can keep doing transactions even if not all secrets have been released."""
number_of_transfers = 100
balance_for_all_transfers = 11 * number_of_transfers
lock_amounts = cycle([1, 3, 5, 7, 11])
lock_secrets = [
format(i, '>032').encode()
for i in range(number_of_transfers)
]
our_model, _ = create_model(70)
partner_model, privkey2 = create_model(balance_for_all_transfers)
channel_state = create_channel_from_models(our_model, partner_model)
block_number = 1000
nonce = 0
transferred_amount = 0
our_model_current = our_model
partner_model_current = partner_model
for i, (lock_amount, lock_secret) in enumerate(zip(lock_amounts, lock_secrets)):
nonce += 1
block_number += 1
lock_expiration = block_number + channel_state.settle_timeout - 1
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
merkletree_leaves = list(partner_model_current.merkletree_leaves)
merkletree_leaves.append(lock.lockhash)
partner_model_current = partner_model_current._replace(
distributable=partner_model_current.distributable - lock_amount,
amount_locked=partner_model_current.amount_locked + lock_amount,
next_nonce=partner_model_current.next_nonce + 1,
merkletree_leaves=merkletree_leaves,
)
receive_lockedtransfer = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce,
transferred_amount,
lock,
merkletree_leaves=merkletree_leaves,
)
is_valid, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert is_valid, msg
assert_partner_state(
channel_state.our_state,
channel_state.partner_state,
our_model_current,
)
assert_partner_state(
channel_state.partner_state,
channel_state.our_state,
partner_model_current,
)
# claim a transaction at every other iteration, leaving the current one
# in place
if i % 2:
# Update our model:
# - Increase nonce because the secret is a new balance proof
# - The lock is removed from the merkle tree, the balance proof must be updated
# - The locksroot must have unlocked lock removed
# - The transferred amount must be increased by the lock amount
# - This changes the balance for both participants:
# - the sender balance and locked amount is decremented by the lock amount
# - the receiver balance and distributable is incremented by the lock amount
nonce += 1
transferred_amount += lock_amount
merkletree_leaves = list(partner_model_current.merkletree_leaves)
merkletree_leaves.remove(lock.lockhash)
tree = compute_layers(merkletree_leaves)
locksroot = tree[MERKLEROOT][0]
partner_model_current = partner_model_current._replace(
amount_locked=partner_model_current.amount_locked - lock_amount,
balance=partner_model_current.balance - lock_amount,
next_nonce=partner_model_current.next_nonce + 1,
merkletree_leaves=merkletree_leaves,
)
our_model_current = our_model_current._replace(
balance=our_model_current.balance + lock_amount,
distributable=our_model_current.distributable + lock_amount,
)
message_identifier = random.randint(0, UINT64_MAX)
secret_message = Secret(
message_identifier=message_identifier,
payment_identifier=nonce,
nonce=nonce,
channel=channel_state.identifier,
transferred_amount=transferred_amount,
locksroot=locksroot,
secret=lock_secret,
)
secret_message.sign(privkey2, channel_state.partner_state.address)
balance_proof = balanceproof_from_envelope(secret_message)
unlock_state_change = ReceiveUnlock(
lock_secret,
balance_proof,
)
is_valid, msg = channel.handle_unlock(channel_state, unlock_state_change)
assert is_valid, msg
assert_partner_state(
channel_state.our_state,
channel_state.partner_state,
our_model_current,
)
assert_partner_state(
channel_state.partner_state,
channel_state.our_state,
partner_model_current,
)
def test_channelstate_receive_lockedtransfer():
"""Tests receiving a mediated transfer.
The transfer is done in three steps:
- a mediated transfer including a lock in its balance proof is sent
- the secret is revealed
- the unlocked balance proof is sent updating the transferred_amount
"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
# Step 1: Simulate receiving a transfer
# - The receiver end state doesnt change
# - The lock must be registered with the sender end
lock_amount = 30
lock_expiration = 10
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
nonce = 1
transferred_amount = 0
receive_lockedtransfer = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce,
transferred_amount,
lock,
)
is_valid, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert is_valid, msg
our_model2 = our_model1
partner_model2 = partner_model1._replace(
distributable=partner_model1.distributable - lock_amount,
amount_locked=lock_amount,
next_nonce=2,
merkletree_leaves=[lock.lockhash],
)
assert_partner_state(channel_state.our_state, channel_state.partner_state, our_model2)
assert_partner_state(channel_state.partner_state, channel_state.our_state, partner_model2)
# Step 2: Simulate learning the secret
# - Registers the secret, this must not change the balance/locked amount
channel.register_secret(channel_state, lock_secret, lock_secrethash)
assert_partner_state(channel_state.our_state, channel_state.partner_state, our_model2)
assert_partner_state(channel_state.partner_state, channel_state.our_state, partner_model2)
# Step 3: Simulate unlocking the lock
# - Update the balances
transferred_amount = 0
message_identifier = random.randint(0, UINT64_MAX)
secret_message = Secret(
message_identifier=message_identifier,
payment_identifier=1,
nonce=2,
channel=channel_state.identifier,
transferred_amount=transferred_amount + lock_amount,
locksroot=EMPTY_MERKLE_ROOT,
secret=lock_secret,
)
secret_message.sign(privkey2, channel_state.partner_state.address)
balance_proof = balanceproof_from_envelope(secret_message)
unlock_state_change = ReceiveUnlock(
lock_secret,
balance_proof,
)
is_valid, msg = channel.handle_unlock(channel_state, unlock_state_change)
assert is_valid, msg
our_model3 = our_model2._replace(
balance=our_model2.balance + lock_amount,
distributable=our_model2.balance + lock_amount,
)
partner_model3 = partner_model2._replace(
balance=partner_model2.balance - lock_amount,
amount_locked=0,
next_nonce=3,
merkletree_leaves=[],
)
assert_partner_state(channel_state.our_state, channel_state.partner_state, our_model3)
assert_partner_state(channel_state.partner_state, channel_state.our_state, partner_model3)
def test_secret(iterations=ITERATIONS):
secret = HASH
msg = Secret(secret)
msg.sign(PRIVKEY)
run_timeit('Secret', msg, iterations=iterations)
def test_end_state():
token_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = make_address()
channel_address = make_address()
balance1 = 70
balance2 = 110
lock_secret = sha3('test_end_state')
lock_amount = 30
lock_expiration = 10
lock_hashlock = sha3(lock_secret)
state1 = ChannelEndState(address1, balance1, None, EMPTY_MERKLE_TREE)
state2 = ChannelEndState(address2, balance2, None, EMPTY_MERKLE_TREE)
assert state1.contract_balance == balance1
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1
assert state2.balance(state1) == balance2
assert state1.is_locked(lock_hashlock) is False
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == EMPTY_MERKLE_ROOT
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is None
assert state2.nonce is None
lock = Lock(
lock_amount,
lock_expiration,
lock_hashlock,
)
lock_hash = sha3(lock.as_bytes)
transferred_amount = 0
locksroot = state2.compute_merkleroot_with(lock)
locked_transfer = LockedTransfer(
1,
nonce=1,
token=token_address,
channel=channel_address,
transferred_amount=transferred_amount,
recipient=state2.address,
locksroot=locksroot,
lock=lock,
)
transfer_target = make_address()
transfer_initiator = make_address()
fee = 0
mediated_transfer = locked_transfer.to_mediatedtransfer(
transfer_target,
transfer_initiator,
fee,
)
mediated_transfer.sign(privkey1, address1)
state1.register_locked_transfer(mediated_transfer)
assert state1.contract_balance == balance1
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1
assert state2.balance(state1) == balance2
assert state1.distributable(state2) == balance1 - lock_amount
assert state2.distributable(state1) == balance2
assert state1.amount_locked == lock_amount
assert state2.amount_locked == 0
assert state1.is_locked(lock_hashlock) is True
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == lock_hash
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 1
assert state2.nonce is None
with pytest.raises(ValueError):
state1.update_contract_balance(balance1 - 10)
state1.update_contract_balance(balance1 + 10)
assert state1.contract_balance == balance1 + 10
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1 + 10
assert state2.balance(state1) == balance2
assert state1.distributable(state2) == balance1 - lock_amount + 10
assert state2.distributable(state1) == balance2
assert state1.amount_locked == lock_amount
assert state2.amount_locked == 0
assert state1.is_locked(lock_hashlock) is True
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == lock_hash
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 1
assert state2.nonce is None
# registering the secret should not change the locked amount
state1.register_secret(lock_secret)
assert state1.contract_balance == balance1 + 10
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1 + 10
assert state2.balance(state1) == balance2
assert state1.is_locked(lock_hashlock) is False
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == lock_hash
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 1
assert state2.nonce is None
secret_message = Secret(
identifier=1,
nonce=2,
channel=channel_address,
transferred_amount=transferred_amount + lock_amount,
locksroot=EMPTY_MERKLE_ROOT,
secret=lock_secret,
)
secret_message.sign(privkey1, address1)
state1.register_secretmessage(secret_message)
assert state1.contract_balance == balance1 + 10
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1 + 10 - lock_amount
assert state2.balance(state1) == balance2 + lock_amount
assert state1.distributable(state2) == balance1 + 10 - lock_amount
assert state2.distributable(state1) == balance2 + lock_amount
assert state1.amount_locked == 0
assert state2.amount_locked == 0
assert state1.is_locked(lock_hashlock) is False
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == EMPTY_MERKLE_ROOT
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 2
assert state2.nonce is None
def test_end_state():
token_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = make_address()
channel_address = make_address()
balance1 = 70
balance2 = 110
lock_secret = sha3(b'test_end_state')
lock_amount = 30
lock_expiration = 10
lock_hashlock = sha3(lock_secret)
state1 = ChannelEndState(address1, balance1, None, EMPTY_MERKLE_TREE)
state2 = ChannelEndState(address2, balance2, None, EMPTY_MERKLE_TREE)
assert state1.contract_balance == balance1
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1
assert state2.balance(state1) == balance2
assert state1.is_locked(lock_hashlock) is False
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == EMPTY_MERKLE_ROOT
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is None
assert state2.nonce is None
lock = Lock(
lock_amount,
lock_expiration,
lock_hashlock,
)
lock_hash = sha3(lock.as_bytes)
transferred_amount = 0
locksroot = state2.compute_merkleroot_with(lock)
locked_transfer = LockedTransfer(
1,
nonce=1,
token=token_address,
channel=channel_address,
transferred_amount=transferred_amount,
recipient=state2.address,
locksroot=locksroot,
lock=lock,
)
transfer_target = make_address()
transfer_initiator = make_address()
fee = 0
mediated_transfer = locked_transfer.to_mediatedtransfer(
transfer_target,
transfer_initiator,
fee,
)
mediated_transfer.sign(privkey1, address1)
state1.register_locked_transfer(mediated_transfer)
assert state1.contract_balance == balance1
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1
assert state2.balance(state1) == balance2
assert state1.distributable(state2) == balance1 - lock_amount
assert state2.distributable(state1) == balance2
assert state1.amount_locked == lock_amount
assert state2.amount_locked == 0
assert state1.is_locked(lock_hashlock) is True
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == lock_hash
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 1
assert state2.nonce is None
with pytest.raises(ValueError):
state1.update_contract_balance(balance1 - 10)
state1.update_contract_balance(balance1 + 10)
assert state1.contract_balance == balance1 + 10
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1 + 10
assert state2.balance(state1) == balance2
assert state1.distributable(state2) == balance1 - lock_amount + 10
assert state2.distributable(state1) == balance2
assert state1.amount_locked == lock_amount
assert state2.amount_locked == 0
assert state1.is_locked(lock_hashlock) is True
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == lock_hash
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 1
assert state2.nonce is None
# registering the secret should not change the locked amount
state1.register_secret(lock_secret)
assert state1.contract_balance == balance1 + 10
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1 + 10
assert state2.balance(state1) == balance2
assert state1.is_locked(lock_hashlock) is False
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == lock_hash
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 1
assert state2.nonce is None
secret_message = Secret(
identifier=1,
nonce=2,
channel=channel_address,
transferred_amount=transferred_amount + lock_amount,
locksroot=EMPTY_MERKLE_ROOT,
secret=lock_secret,
)
secret_message.sign(privkey1, address1)
state1.register_secretmessage(secret_message)
assert state1.contract_balance == balance1 + 10
assert state2.contract_balance == balance2
assert state1.balance(state2) == balance1 + 10 - lock_amount
assert state2.balance(state1) == balance2 + lock_amount
assert state1.distributable(state2) == balance1 + 10 - lock_amount
assert state2.distributable(state1) == balance2 + lock_amount
assert state1.amount_locked == 0
assert state2.amount_locked == 0
assert state1.is_locked(lock_hashlock) is False
assert state2.is_locked(lock_hashlock) is False
assert merkleroot(state1.merkletree) == EMPTY_MERKLE_ROOT
assert merkleroot(state2.merkletree) == EMPTY_MERKLE_ROOT
assert state1.nonce is 2
assert state2.nonce is None
def test_secret(iterations=ITERATIONS):
secret = HASH
msg = Secret(secret)
msg.sign(PRIVKEY)
run_timeit('Secret', msg, iterations=iterations)