def test_channel_must_accept_expired_locks():
"""A node may go offline for an undetermined period of time, and when it
comes back online it must accept the messages that are waiting, otherwise
the partner node won't make progress with its queue.
If a N node goes offline for a number B of blocks, and the partner does not
close the channel, when N comes back online some of the messages from its
partner may become expired. Nevertheless these messages are ordered and must
be accepted for the partner to make progress with its queue.
Note: Accepting a message with an expired lock does *not* imply the token
transfer happened, and the receiver node must *not* forward the transfer,
only accept the message allowing the partner to progress with its message
queue.
"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
block_number = 100
lock_amount = 10
lock_expiration = block_number - 10
lock_secrethash = sha3(b'test_channel_must_accept_expired_locks')
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
# the locked amount must increase even though the lock is expired, this
# will be removed by an additional synchronization message from the partner
our_model2 = our_model1
partner_model2 = partner_model1._replace(
amount_locked=lock_amount,
distributable=partner_model1.distributable - lock_amount,
next_nonce=partner_model1.next_nonce + 1,
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)
def _channel_and_transfer(merkletree_width):
our_model, _ = create_model(700)
partner_model, privkey = create_model(700, merkletree_width)
reverse_channel_state = create_channel_from_models(partner_model,
our_model)
lock_secret = sha3(b"some secret")
lock = HashTimeLockState(30, 10, sha3(lock_secret))
mediated_transfer = make_receive_transfer_mediated(
reverse_channel_state,
privkey,
nonce=1,
transferred_amount=0,
lock=lock,
merkletree_leaves=partner_model.merkletree_leaves + [lock.lockhash],
locked_amount=lock.amount,
)
channel_state = deepcopy(reverse_channel_state)
channel_state.our_state = reverse_channel_state.partner_state
channel_state.partner_state = reverse_channel_state.our_state
return channel_state, mediated_transfer
def _channel_and_transfer(num_pending_locks):
our_model, _ = create_model(700)
partner_model, privkey = create_model(700, num_pending_locks)
reverse_channel_state = create_channel_from_models(partner_model,
our_model, privkey)
lock_secret = sha3(b"some secret seed")
lock = HashTimeLockState(30, 10, sha256(lock_secret).digest())
mediated_transfer = make_receive_transfer_mediated(
reverse_channel_state,
privkey,
nonce=partner_model.next_nonce,
transferred_amount=0,
lock=lock,
pending_locks=PendingLocksState(partner_model.pending_locks +
[bytes(lock.encoded)]),
locked_amount=lock.amount,
)
channel_state = deepcopy(reverse_channel_state)
channel_state.our_state = reverse_channel_state.partner_state
channel_state.partner_state = reverse_channel_state.our_state
return channel_state, mediated_transfer
def lockedtransfersigned_from_message(message):
""" Create LockedTransferSignedState from a LockedTransfer message. """
balance_proof = BalanceProofSignedState(
message.nonce,
message.transferred_amount,
message.locksroot,
message.channel,
message.message_hash,
message.signature,
message.sender,
)
lock = HashTimeLockState(
message.lock.amount,
message.lock.expiration,
message.lock.secrethash,
)
transfer_state = LockedTransferSignedState(
message.payment_identifier,
message.token,
balance_proof,
lock,
message.initiator,
message.target,
)
return transfer_state
def test_channel_withdraw_must_not_change_merkletree():
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
lock_amount = 10
lock_expiration = 100
lock_secret = sha3(b'test_channelstate_lockedtransfer_overspent')
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
assert merkleroot(channel_state.partner_state.merkletree) == lock.lockhash
assert channel.is_lock_pending(channel_state.partner_state,
lock.secrethash)
closed_block_number = lock_expiration - channel_state.reveal_timeout - 1
state_change = ContractReceiveChannelClosed(
payment_network_identifier,
channel_state.token_address,
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, state_change)
new_channel = iteration.new_state
withdraw = ContractReceiveChannelWithdraw(
payment_network_identifier,
channel_state.token_address,
channel_state.identifier,
lock_secret,
channel_state.our_state.address,
)
iteration = channel.handle_channel_withdraw(new_channel, withdraw)
new_channel = iteration.new_state
assert merkleroot(new_channel.partner_state.merkletree) == lock.lockhash
assert not channel.is_lock_pending(new_channel.partner_state,
lock.secrethash)
def _update_balance_proof_data(self, partner, amount, expiration, secret):
expected = self._get_balance_proof_data(partner)
lock = HashTimeLockState(amount=amount,
expiration=expiration,
secrethash=sha256_secrethash(secret))
expected.update(amount, lock)
return expected
def test_receive_lockedtransfer_before_deposit():
"""Regression test that ensures we accept incoming mediated transfers, even if we don't have
any balance on the channel.
"""
our_model1, _ = create_model(0) # our deposit is 0
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
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,
)
# this node partner has enough balance, the transfer must be accepted
assert is_valid, msg
def test_get_secret():
secret1 = factories.make_secret()
secret2 = factories.make_secret()
secrethash3 = factories.make_keccak_hash()
secrethash4 = factories.make_keccak_hash()
lock_state = HashTimeLockState(amount=10,
expiration=10,
secrethash=factories.UNIT_SECRETHASH)
end_state = factories.create(factories.NettingChannelEndStateProperties())
end_state = factories.replace(
end_state,
secrethashes_to_lockedlocks={secrethash3: lock_state},
secrethashes_to_unlockedlocks={
sha3(secret1): UnlockPartialProofState(lock=lock_state,
secret=secret1)
},
secrethashes_to_onchain_unlockedlocks={
sha3(secret2): UnlockPartialProofState(lock=lock_state,
secret=secret2)
},
)
assert get_secret(
end_state,
sha3(secret1)) == secret1 # known secret from offchain unlock
assert get_secret(
end_state,
sha3(secret2)) == secret2 # known secret from offchain unlock
assert get_secret(end_state,
secrethash3) is None # known lock but not unlocked yet
assert get_secret(end_state, secrethash4) is None # unknown secrethash
def create_sendmediatedtransfer(channel_state, initiator, target, amount,
identifier, expiration, secrethash):
our_state = channel_state.our_state
partner_state = channel_state.partner_state
our_balance_proof = our_state.balance_proof
msg = 'caller must make sure there is enough balance'
assert amount <= get_distributable(our_state, partner_state), msg
msg = 'caller must make sure the channel is open'
assert get_status(channel_state) == CHANNEL_STATE_OPENED, msg
lock = HashTimeLockState(
amount,
expiration,
secrethash,
)
merkletree = compute_merkletree_with(
channel_state.our_state.merkletree,
lock.lockhash,
)
# The caller must ensure the same lock is not being used twice
assert merkletree, 'lock is already registered'
locksroot = merkleroot(merkletree)
if our_balance_proof:
transferred_amount = our_balance_proof.transferred_amount
else:
transferred_amount = 0
token = channel_state.token_address
nonce = get_next_nonce(channel_state.our_state)
recipient = channel_state.partner_state.address
balance_proof = BalanceProofUnsignedState(
nonce,
transferred_amount,
locksroot,
channel_state.identifier,
)
locked_transfer = LockedTransferUnsignedState(
identifier,
token,
balance_proof,
lock,
initiator,
target,
)
mediatedtransfer = SendMediatedTransfer(
locked_transfer,
recipient,
)
return mediatedtransfer, merkletree
def test_channelstate_unlock():
"""The node must call unlock after the channel is settled"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
lock_amount = 10
lock_expiration = 100
lock_secret = sha3(b'test_channelstate_lockedtransfer_overspent')
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
channel.register_secret(channel_state, lock_secret, lock_secrethash)
closed_block_number = lock_expiration - channel_state.reveal_timeout - 1
close_state_change = ContractReceiveChannelClosed(
channel_state.token_network_identifier,
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, close_state_change)
assert not must_contain_entry(iteration.events, ContractSendChannelBatchUnlock, {})
settle_block_number = lock_expiration + channel_state.reveal_timeout + 1
settle_state_change = ContractReceiveChannelSettled(
channel_state.token_network_identifier,
channel_state.identifier,
settle_block_number,
)
iteration = channel.handle_channel_settled(
channel_state,
settle_state_change,
settle_block_number,
)
assert must_contain_entry(iteration.events, ContractSendChannelBatchUnlock, {})
def test_channelstate_send_lockedtransfer():
"""Sending a mediated transfer must update the participant state.
This tests only the state of the sending node, without synchronisation.
"""
our_model1, _ = create_model(70)
partner_model1, _ = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
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,
)
payment_identifier = 1
message_identifier = random.randint(0, UINT64_MAX)
transfer_target = factories.make_address()
transfer_initiator = factories.make_address()
registry_address = factories.make_address()
channel.send_lockedtransfer(
registry_address,
channel_state,
transfer_initiator,
transfer_target,
lock_amount,
message_identifier,
payment_identifier,
lock_expiration,
lock_secrethash,
)
our_model2 = our_model1._replace(
distributable=our_model1.distributable - lock_amount,
amount_locked=lock_amount,
next_nonce=2,
merkletree_leaves=[lock.lockhash],
)
partner_model2 = partner_model1
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)
def test_channelstate_get_unlock_proof():
number_of_transfers = 100
lock_amounts = cycle([1, 3, 5, 7, 11])
lock_secrets = [
make_secret(i)
for i in range(number_of_transfers)
]
block_number = 1000
locked_amount = 0
settle_timeout = 8
merkletree_leaves = []
locked_locks = {}
unlocked_locks = {}
for lock_amount, lock_secret in zip(lock_amounts, lock_secrets):
block_number += 1
locked_amount += lock_amount
lock_expiration = block_number + settle_timeout
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
merkletree_leaves.append(lock.lockhash)
if random.randint(0, 1) == 0:
locked_locks[lock_secrethash] = lock
else:
unlocked_locks[lock_secrethash] = UnlockPartialProofState(lock, lock_secret)
end_state = NettingChannelEndState(HOP1, 300)
end_state.secrethashes_to_lockedlocks = locked_locks
end_state.secrethashes_to_unlockedlocks = unlocked_locks
end_state.merkletree = MerkleTreeState(compute_layers(merkletree_leaves))
unlock_proof = channel.get_batch_unlock(end_state)
assert len(unlock_proof) == len(end_state.merkletree.layers[LEAVES])
leaves_packed = b''.join(lock.encoded for lock in unlock_proof)
recomputed_merkle_tree = MerkleTreeState(compute_layers(
merkle_leaves_from_packed_data(leaves_packed),
))
assert len(recomputed_merkle_tree.layers[LEAVES]) == len(end_state.merkletree.layers[LEAVES])
computed_merkleroot = merkleroot(recomputed_merkle_tree)
assert merkleroot(end_state.merkletree) == computed_merkleroot
def test_channelstate_withdraw():
"""Event close must be properly handled if there are no locks to unlock"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
lock_amount = 10
lock_expiration = 100
lock_secret = sha3(b'test_channelstate_lockedtransfer_overspent')
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
channel.register_secret(channel_state, lock_secret, lock_secrethash)
# If the channel is closed, withdraw must be done even if the lock is not
# at risk of expiring
closed_block_number = lock_expiration - channel_state.reveal_timeout - 1
state_change = ContractReceiveChannelClosed(
payment_network_identifier,
channel_state.token_address,
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, state_change)
assert must_contain_entry(iteration.events, ContractSendChannelWithdraw,
{})
def lockedtransfersigned_from_message(message: LockedTransferBase) -> LockedTransferSignedState:
""" Create LockedTransferSignedState from a LockedTransfer message. """
balance_proof = balanceproof_from_envelope(message)
lock = HashTimeLockState(message.lock.amount, message.lock.expiration, message.lock.secrethash)
transfer_state = LockedTransferSignedState(
message_identifier=message.message_identifier,
payment_identifier=message.payment_identifier,
token=message.token,
balance_proof=balance_proof,
lock=lock,
initiator=message.initiator,
target=message.target,
routes=[r.route for r in message.metadata.routes],
)
return transfer_state
def lockedtransfersigned_from_message(message: "LockedTransfer") -> "LockedTransferSignedState":
""" Create LockedTransferSignedState from a LockedTransfer message. """
balance_proof = balanceproof_from_envelope(message)
lock = HashTimeLockState(message.lock.amount, message.lock.expiration, message.lock.secrethash)
transfer_state = LockedTransferSignedState(
message.message_identifier,
message.payment_identifier,
message.token,
balance_proof,
lock,
message.initiator,
message.target,
)
return transfer_state
def test_channelstate_lockedtransfer_invalid_chainid():
"""Receiving a locked transfer with chain_id different from the channel's
chain_id should be ignored
"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
distributable = channel.get_distributable(channel_state.partner_state, channel_state.our_state)
lock_amount = distributable - 1
lock_expiration = 10
lock_secrethash = sha3(b'test_channelstate_lockedtransfer_overspent')
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,
chain_id=UNIT_CHAIN_ID + 1,
)
is_valid, _, _ = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert not is_valid, (
'message is invalid because it uses different chain_id than the channel'
)
assert_partner_state(channel_state.our_state, channel_state.partner_state, our_model1)
assert_partner_state(channel_state.partner_state, channel_state.our_state, partner_model1)
def test_channelstate_lockedtransfer_overspent():
"""Receiving a lock with an amount large than distributable must be
ignored.
"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
distributable = channel.get_distributable(channel_state.partner_state,
channel_state.our_state)
lock_amount = distributable + 1
lock_expiration = 10
lock_secrethash = sha3(b'test_channelstate_lockedtransfer_overspent')
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, _, _ = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert not is_valid, 'message is invalid because it is spending more than the distributable'
assert_partner_state(channel_state.our_state, channel_state.partner_state,
our_model1)
assert_partner_state(channel_state.partner_state, channel_state.our_state,
partner_model1)
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 make_hash_time_lock_state(amount) -> HashTimeLockState:
return HashTimeLockState(amount=amount,
expiration=BlockExpiration(5),
secrethash=factories.UNIT_SECRETHASH)
def test_mediator_clear_pairs_after_batch_unlock(
chain_state,
token_network_state,
our_address,
):
""" Regression test for https://github.com/raiden-network/raiden/issues/2932
The mediator must also clear the transfer pairs once a ReceiveBatchUnlock where
he is a participant is received.
"""
open_block_number = 10
pseudo_random_generator = random.Random()
pkey, address = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address,
token_network_identifier=token_network_state.address,
)
payment_network_identifier = factories.make_payment_network_identifier()
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
channel_state,
open_block_number,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock,
)
from_route = factories.route_from_channel(channel_state)
init_mediator = ActionInitMediator(
routes=[from_route],
from_route=from_route,
from_transfer=mediated_transfer,
)
node.state_transition(chain_state, init_mediator)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
factories.make_transaction_hash(),
channel_state.partner_state.address,
token_network_state.address,
channel_state.identifier,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
payment_network_identifier,
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
factories.make_transaction_hash(),
token_network_state.address,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
payment_network_identifier,
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
block_number = closed_block_number + 1
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=block_number,
)
channel_unlock_iteration = node.state_transition(
chain_state=chain_state,
state_change=channel_batch_unlock_state_change,
)
chain_state = channel_unlock_iteration.new_state
token_network_state = views.get_token_network_by_identifier(
chain_state=chain_state,
token_network_id=token_network_state.address,
)
ids_to_channels = token_network_state.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
# Make sure that all is fine in the next block
block = Block(
block_number=block_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
iteration = node.state_transition(
chain_state=chain_state,
state_change=block,
)
assert iteration.new_state
# Make sure that mediator task was cleared during the next block processing
# since the channel was removed
mediator_task = chain_state.payment_mapping.secrethashes_to_task.get(
lock_secrethash)
assert not mediator_task
def test_pfs_global_messages(
matrix_transports,
monkeypatch,
):
"""
Test that `update_pfs` from `RaidenEventHandler` sends balance proof updates to the global
PATH_FINDING_BROADCASTING_ROOM room on Send($BalanceProof)* events, i.e. events, that send
a new balance proof to the channel partner.
"""
transport = matrix_transports[0]
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
# create mock events that should trigger a send
lock = make_lock()
hash_time_lock = HashTimeLockState(lock.amount, lock.expiration,
lock.secrethash)
def make_unsigned_balance_proof(nonce):
return BalanceProofUnsignedState.from_dict(
make_balance_proof(nonce=nonce,
signer=LocalSigner(HOP1_KEY),
amount=1).to_dict(), )
transfer1 = LockedTransferUnsignedState(
balance_proof=make_unsigned_balance_proof(nonce=1),
payment_identifier=1,
token=b'1',
lock=hash_time_lock,
target=HOP1,
initiator=HOP1,
)
transfer2 = LockedTransferUnsignedState(
balance_proof=make_unsigned_balance_proof(nonce=2),
payment_identifier=1,
token=b'1',
lock=hash_time_lock,
target=HOP1,
initiator=HOP1,
)
send_balance_proof_events = [
SendLockedTransfer(HOP1, 1, 1, transfer1),
SendRefundTransfer(HOP1, 1, 1, transfer2),
SendBalanceProof(HOP1, 1, 1, 1, b'1', b'x' * 32,
make_unsigned_balance_proof(nonce=3)),
SendLockExpired(HOP1, 1, make_unsigned_balance_proof(nonce=4),
b'x' * 32),
]
for num, event in enumerate(send_balance_proof_events):
assert event.balance_proof.nonce == num + 1
# make sure we cover all configured event types
assert all(event in [type(event) for event in send_balance_proof_events]
for event in SEND_BALANCE_PROOF_EVENTS)
event_handler = raiden_event_handler.RaidenEventHandler()
# let our mock objects pass validation
channelstate_mock = Mock()
channelstate_mock.reveal_timeout = 1
monkeypatch.setattr(
raiden_event_handler,
'get_channelstate_by_token_network_and_partner',
lambda *args, **kwargs: channelstate_mock,
)
monkeypatch.setattr(raiden_event_handler, 'state_from_raiden',
lambda *args, **kwargs: 1)
monkeypatch.setattr(event_handler, 'handle_send_lockedtransfer',
lambda *args, **kwargs: 1)
monkeypatch.setattr(event_handler, 'handle_send_refundtransfer',
lambda *args, **kwargs: 1)
# handle the events
for event in send_balance_proof_events:
event_handler.on_raiden_event(
raiden_service,
event,
)
gevent.idle()
# ensure all events triggered a send for their respective balance_proof
# matrix transport may concatenate multiple messages send in one interval
assert pfs_room.send_text.call_count >= 1
concatenated_call_args = ' '.join(
str(arg) for arg in pfs_room.send_text.call_args_list)
assert all(f'"nonce": {i + 1}' in concatenated_call_args
for i in range(len(SEND_BALANCE_PROOF_EVENTS)))
transport.stop()
transport.get()
def test_channel_data_removed_after_unlock(chain_state, token_network_state,
our_address, channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
lock_amount = 30
lock_expiration = 20
lock_secret = keccak(b"test_end_state")
lock_secrethash = sha256(lock_secret).digest()
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_hop = factories.make_hop_from_channel(channel_state)
init_target = ActionInitTarget(
sender=mediated_transfer.balance_proof.sender, # pylint: disable=no-member
balance_proof=mediated_transfer.balance_proof,
from_hop=from_hop,
transfer=mediated_transfer,
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
channel_state_after_closed = channel_closed_iteration.new_state.channelidentifiers_to_channels[
channel_state.identifier]
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=compute_locksroot(
channel_state_after_closed.our_state.pending_locks),
partner_onchain_locksroot=compute_locksroot(
channel_state_after_closed.partner_state.pending_locks),
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
receiver=our_address,
sender=address,
locksroot=compute_locksroot(PendingLocksState([bytes(lock.encoded)])),
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = token_network.state_transition(
token_network_state=channel_settled_iteration.new_state,
state_change=channel_batch_unlock_state_change,
block_number=unlock_blocknumber,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
def create_sendlockedtransfer(
channel_state: NettingChannelState,
initiator: typing.InitiatorAddress,
target: typing.TargetAddress,
amount: typing.PaymentAmount,
message_identifier: typing.MessageID,
payment_identifier: typing.PaymentID,
expiration: typing.BlockExpiration,
secrethash: typing.SecretHash,
) -> SendLockedTransfer:
our_state = channel_state.our_state
partner_state = channel_state.partner_state
our_balance_proof = our_state.balance_proof
msg = 'caller must make sure there is enough balance'
assert amount <= get_distributable(our_state, partner_state), msg
msg = 'caller must make sure the channel is open'
assert get_status(channel_state) == CHANNEL_STATE_OPENED, msg
lock = HashTimeLockState(
amount,
expiration,
secrethash,
)
merkletree = compute_merkletree_with(
channel_state.our_state.merkletree,
lock.lockhash,
)
# The caller must ensure the same lock is not being used twice
assert merkletree, 'lock is already registered'
locksroot = merkleroot(merkletree)
if our_balance_proof:
transferred_amount = our_balance_proof.transferred_amount
else:
transferred_amount = 0
token = channel_state.token_address
nonce = get_next_nonce(channel_state.our_state)
recipient = channel_state.partner_state.address
locked_amount = get_amount_locked(
our_state) + amount # the new lock is not registered yet
balance_proof = BalanceProofUnsignedState(
nonce,
transferred_amount,
locked_amount,
locksroot,
channel_state.token_network_identifier,
channel_state.identifier,
)
locked_transfer = LockedTransferUnsignedState(
payment_identifier,
token,
balance_proof,
lock,
initiator,
target,
)
queue_name = channel_state.identifier
lockedtransfer = SendLockedTransfer(
recipient,
queue_name,
message_identifier,
locked_transfer,
)
return lockedtransfer, merkletree
def test_mediator_clear_pairs_after_batch_unlock(chain_state,
token_network_state,
our_address,
channel_properties):
""" Regression test for https://github.com/raiden-network/raiden/issues/2932
The mediator must also clear the transfer pairs once a ReceiveBatchUnlock where
he is a participant is received.
"""
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
lock_amount = 30
lock_expiration = 20
lock_secret = keccak(b"test_end_state")
lock_secrethash = sha256(lock_secret).digest()
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
route_state = RouteState(
route=[
channel_state.our_state.address,
channel_state.partner_state.address
],
forward_channel_id=channel_state.canonical_identifier.
channel_identifier,
)
from_hop = factories.make_hop_from_channel(channel_state)
init_mediator = ActionInitMediator(
route_states=[route_state],
from_hop=from_hop,
from_transfer=mediated_transfer,
balance_proof=mediated_transfer.balance_proof,
sender=mediated_transfer.balance_proof.sender, # pylint: disable=no-member
)
node.state_transition(chain_state, init_mediator)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=LOCKSROOT_OF_NO_LOCKS,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
block_number = closed_block_number + 1
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
receiver=address,
sender=our_address,
locksroot=compute_locksroot(PendingLocksState([bytes(lock.encoded)])),
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=block_number,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = node.state_transition(
chain_state=chain_state,
state_change=channel_batch_unlock_state_change)
chain_state = channel_unlock_iteration.new_state
token_network_state = views.get_token_network_by_address(
chain_state=chain_state,
token_network_address=token_network_state.address)
ids_to_channels = token_network_state.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
# Make sure that all is fine in the next block
block = Block(block_number=block_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash())
iteration = node.state_transition(chain_state=chain_state,
state_change=block)
assert iteration.new_state
# Make sure that mediator task was cleared during the next block processing
# since the channel was removed
mediator_task = chain_state.payment_mapping.secrethashes_to_task.get(
lock_secrethash)
assert not mediator_task
def test_multiple_channel_states(chain_state, token_network_state,
channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
properties, pkey = channel_properties
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
lock_amount = 30
lock_expiration = 20
lock_secret = keccak(b"test_end_state")
lock_secrethash = sha256(lock_secret).digest()
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_hop = factories.make_hop_from_channel(channel_state)
init_target = ActionInitTarget(
from_hop=from_hop,
transfer=mediated_transfer,
balance_proof=mediated_transfer.balance_proof,
sender=mediated_transfer.balance_proof.sender, # pylint: disable=no-member
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=LOCKSROOT_OF_NO_LOCKS,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
# Create new channel while the previous one is pending unlock
new_channel_properties = factories.create_properties(
factories.NettingChannelStateProperties(
canonical_identifier=factories.make_canonical_identifier()),
defaults=properties,
)
new_channel_state = factories.create(new_channel_properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=new_channel_state,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_new_open = channel_new_iteration.new_state
ids_to_channels = token_network_state_after_new_open.channelidentifiers_to_channels
assert len(ids_to_channels) == 2
assert channel_state.identifier in ids_to_channels
def test_channel_data_removed_after_unlock(
chain_state,
token_network_state,
our_address,
):
open_block_number = 10
pseudo_random_generator = random.Random()
pkey, address = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address,
token_network_identifier=token_network_state.address,
)
payment_network_identifier = factories.make_payment_network_identifier()
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
channel_state,
open_block_number,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock,
)
from_route = factories.route_from_channel(channel_state)
init_target = ActionInitTarget(
from_route,
mediated_transfer,
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
factories.make_transaction_hash(),
channel_state.partner_state.address,
token_network_state.address,
channel_state.identifier,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
payment_network_identifier,
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
factories.make_transaction_hash(),
token_network_state.address,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
payment_network_identifier,
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
)
channel_unlock_iteration = token_network.state_transition(
payment_network_identifier,
channel_settled_iteration.new_state,
channel_batch_unlock_state_change,
pseudo_random_generator,
unlock_blocknumber,
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
def test_channelstate_lockedtransfer_overspend_with_multiple_pending_transfers():
"""Receiving a concurrent lock with an amount large than distributable
must be ignored.
"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
# Step 1: Create a lock with an amount of 1
# - this wont be unlocked
lock1_amount = 1
lock1_expiration = 1 + channel_state.settle_timeout
lock1_secrethash = sha3(b'test_receive_cannot_overspend_with_multiple_pending_transfers1')
lock1 = HashTimeLockState(
lock1_amount,
lock1_expiration,
lock1_secrethash,
)
nonce1 = 1
transferred_amount = 0
receive_lockedtransfer1 = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce1,
transferred_amount,
lock1,
)
is_valid, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer1,
)
assert is_valid, msg
our_model2 = our_model1
partner_model2 = partner_model1._replace(
distributable=partner_model1.distributable - lock1.amount,
amount_locked=lock1.amount,
next_nonce=2,
merkletree_leaves=[lock1.lockhash],
)
# The valid transfer is handled normally
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: Create a lock with the current *distributable + 1*
# - This must be ignored
distributable = channel.get_distributable(channel_state.partner_state, channel_state.our_state)
lock2_amount = distributable + 1
lock2_expiration = channel_state.settle_timeout
lock2_secrethash = sha3(b'test_receive_cannot_overspend_with_multiple_pending_transfers2')
lock2 = HashTimeLockState(
lock2_amount,
lock2_expiration,
lock2_secrethash,
)
leaves = [lock1.lockhash, lock2.lockhash]
nonce2 = 2
receive_lockedtransfer2 = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce2,
transferred_amount,
lock2,
merkletree_leaves=leaves,
)
is_valid, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer2,
)
assert not is_valid, 'message is invalid because its expending more than the distributable'
# The overspending transfer must be ignored
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)
def test_multiple_channel_states(
chain_state,
token_network_state,
our_address,
):
open_block_number = 10
pseudo_random_generator = random.Random()
pkey, address = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address,
)
payment_network_identifier = factories.make_payment_network_identifier()
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
channel_state,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock,
token_network_address=token_network_state.address,
)
from_route = factories.route_from_channel(channel_state)
init_target = ActionInitTarget(
from_route,
mediated_transfer,
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
factories.make_transaction_hash(),
channel_state.partner_state.address,
token_network_state.address,
channel_state.identifier,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
payment_network_identifier,
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
factories.make_transaction_hash(),
token_network_state.address,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
payment_network_identifier,
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
# Create new channel while the previous one is pending unlock
new_channel_state = factories.make_channel(
our_balance=our_balance,
partner_balance=our_balance,
partner_address=address,
)
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
new_channel_state,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
token_network_state_after_new_open = channel_new_iteration.new_state
ids_to_channels = token_network_state_after_new_open.channelidentifiers_to_channels
assert len(ids_to_channels) == 2
assert channel_state.identifier in ids_to_channels
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_channel_data_removed_after_unlock(chain_state, token_network_state,
our_address, channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_target = ActionInitTarget(from_route, mediated_transfer)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = token_network.state_transition(
token_network_state=channel_settled_iteration.new_state,
state_change=channel_batch_unlock_state_change,
block_number=unlock_blocknumber,
block_hash=factories.make_block_hash(),
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
