def assert_balance(from_channel: NettingChannelState, balance: Balance,
locked: LockedAmount) -> None:
""" Assert the from_channel overall token values. """
assert balance >= 0
assert locked >= 0
distributable = balance - locked
channel_distributable = channel.get_distributable(
from_channel.our_state, from_channel.partner_state)
channel_balance = channel.get_balance(from_channel.our_state,
from_channel.partner_state)
channel_locked_amount = channel.get_amount_locked(from_channel.our_state)
msg = f"channel balance does not match. Expected: {balance} got: {channel_balance}"
assert channel_balance == balance, msg
msg = (f"channel distributable amount does not match. "
f"Expected: {distributable} got: {channel_distributable}")
assert channel_distributable == distributable, msg
msg = f"channel locked amount does not match. Expected: {locked} got: {channel_locked_amount}"
assert channel_locked_amount == locked, msg
msg = (f"locked_amount ({locked}) + distributable ({distributable}) "
f"did not equal the balance ({balance})")
assert balance == locked + distributable, msg
def assert_balance(from_channel, balance, locked):
""" Assert the from_channel overall token values. """
assert balance >= 0
assert locked >= 0
distributable = balance - locked
channel_distributable = channel.get_distributable(
from_channel.our_state,
from_channel.partner_state,
)
assert channel.get_balance(from_channel.our_state, from_channel.partner_state) == balance
assert channel_distributable == distributable
assert channel.get_amount_locked(from_channel.our_state) == locked
amount_locked = channel.get_amount_locked(from_channel.our_state)
assert balance == amount_locked + distributable
def assert_mirror(original, mirror):
""" Assert that `mirror` has a correct `partner_state` to represent `original`."""
original_locked_amount = channel.get_amount_locked(original.our_state)
mirror_locked_amount = channel.get_amount_locked(mirror.partner_state)
assert original_locked_amount == mirror_locked_amount
balance0 = channel.get_balance(original.our_state, original.partner_state)
balance1 = channel.get_balance(mirror.partner_state, mirror.our_state)
assert balance0 == balance1
balanceproof0 = channel.get_current_balanceproof(original.our_state)
balanceproof1 = channel.get_current_balanceproof(mirror.partner_state)
assert balanceproof0 == balanceproof1
distributable0 = channel.get_distributable(original.our_state, original.partner_state)
distributable1 = channel.get_distributable(mirror.partner_state, mirror.our_state)
assert distributable0 == distributable1
def assert_balance(from_channel, balance, locked):
""" Assert the from_channel overall token values. """
assert balance >= 0
assert locked >= 0
distributable = balance - locked
channel_distributable = channel.get_distributable(
from_channel.our_state,
from_channel.partner_state,
)
assert channel.get_balance(from_channel.our_state, from_channel.partner_state) == balance
assert channel_distributable == distributable
assert channel.get_amount_locked(from_channel.our_state) == locked
amount_locked = channel.get_amount_locked(from_channel.our_state)
assert balance == amount_locked + distributable
def assert_mirror(original, mirror):
""" Assert that `mirror` has a correct `partner_state` to represent `original`."""
original_locked_amount = channel.get_amount_locked(original.our_state)
mirror_locked_amount = channel.get_amount_locked(mirror.partner_state)
assert original_locked_amount == mirror_locked_amount
balance0 = channel.get_balance(original.our_state, original.partner_state)
balance1 = channel.get_balance(mirror.partner_state, mirror.our_state)
assert balance0 == balance1
balanceproof0 = channel.get_current_balanceproof(original.our_state)
balanceproof1 = channel.get_current_balanceproof(mirror.partner_state)
assert balanceproof0 == balanceproof1
distributable0 = channel.get_distributable(original.our_state, original.partner_state)
distributable1 = channel.get_distributable(mirror.partner_state, mirror.our_state)
assert distributable0 == distributable1
def assert_partner_state(end_state, partner_state, model):
"""Checks that the stored data for both ends correspond to the model."""
assert end_state.address == model.participant_address
assert channel.get_amount_locked(end_state) == model.amount_locked
assert channel.get_balance(end_state, partner_state) == model.balance
assert channel.get_distributable(end_state, partner_state) == model.distributable
assert channel.get_next_nonce(end_state) == model.next_nonce
assert set(end_state.merkletree.layers[LEAVES]) == set(model.merkletree_leaves)
assert end_state.contract_balance == model.contract_balance
def channel_state_invariants(self):
""" Check the invariants for the channel state given in the Raiden specification """
for netting_channel in self.address_to_channel.values():
our_state = netting_channel.our_state
partner_state = netting_channel.partner_state
our_transferred_amount = 0
if our_state.balance_proof:
our_transferred_amount = our_state.balance_proof.transferred_amount
assert our_transferred_amount >= 0
partner_transferred_amount = 0
if partner_state.balance_proof:
partner_transferred_amount = partner_state.balance_proof.transferred_amount
assert partner_transferred_amount >= 0
assert channel.get_distributable(our_state, partner_state) >= 0
assert channel.get_distributable(partner_state, our_state) >= 0
our_deposit = netting_channel.our_total_deposit
partner_deposit = netting_channel.partner_total_deposit
total_deposit = our_deposit + partner_deposit
our_amount_locked = channel.get_amount_locked(our_state)
our_balance = channel.get_balance(our_state, partner_state)
partner_amount_locked = channel.get_amount_locked(partner_state)
partner_balance = channel.get_balance(partner_state, our_state)
# invariant (5.1R), add withdrawn amounts when implemented
assert 0 <= our_amount_locked <= our_balance
assert 0 <= partner_amount_locked <= partner_balance
assert our_amount_locked <= total_deposit
assert partner_amount_locked <= total_deposit
our_transferred = partner_transferred_amount - our_transferred_amount
netted_transferred = our_transferred + partner_amount_locked - our_amount_locked
# invariant (6R), add withdrawn amounts when implemented
assert 0 <= our_deposit + our_transferred - our_amount_locked <= total_deposit
assert 0 <= partner_deposit - our_transferred - partner_amount_locked <= total_deposit
# invariant (7R), add withdrawn amounts when implemented
assert -our_deposit <= netted_transferred <= partner_deposit
def channel_state_invariants(self):
""" Check the invariants for the channel state given in the Raiden specification """
for netting_channel in self.address_to_channel.values():
our_state = netting_channel.our_state
partner_state = netting_channel.partner_state
our_transferred_amount = 0
if our_state.balance_proof:
our_transferred_amount = our_state.balance_proof.transferred_amount
assert our_transferred_amount >= 0
partner_transferred_amount = 0
if partner_state.balance_proof:
partner_transferred_amount = partner_state.balance_proof.transferred_amount
assert partner_transferred_amount >= 0
assert channel.get_distributable(our_state, partner_state) >= 0
assert channel.get_distributable(partner_state, our_state) >= 0
our_deposit = netting_channel.our_total_deposit
partner_deposit = netting_channel.partner_total_deposit
total_deposit = our_deposit + partner_deposit
our_amount_locked = channel.get_amount_locked(our_state)
our_balance = channel.get_balance(our_state, partner_state)
partner_amount_locked = channel.get_amount_locked(partner_state)
partner_balance = channel.get_balance(partner_state, our_state)
# invariant (5.1R), add withdrawn amounts when implemented
assert 0 <= our_amount_locked <= our_balance
assert 0 <= partner_amount_locked <= partner_balance
assert our_amount_locked <= total_deposit
assert partner_amount_locked <= total_deposit
our_transferred = partner_transferred_amount - our_transferred_amount
netted_transferred = our_transferred + partner_amount_locked - our_amount_locked
# invariant (6R), add withdrawn amounts when implemented
assert 0 <= our_deposit + our_transferred - our_amount_locked <= total_deposit
assert 0 <= partner_deposit - our_transferred - partner_amount_locked <= total_deposit
# invariant (7R), add withdrawn amounts when implemented
assert - our_deposit <= netted_transferred <= partner_deposit
def make_receive_transfer_direct(
payment_network_identifier,
channel_state,
privkey,
nonce,
transferred_amount,
locksroot=EMPTY_MERKLE_ROOT,
registry_address=UNIT_REGISTRY_IDENTIFIER,
locked_amount=None,
):
address = privatekey_to_address(privkey.secret)
if address not in (channel_state.our_state.address,
channel_state.partner_state.address):
raise ValueError('Private key does not match any of the participants.')
if locked_amount is None:
locked_amount = channel.get_amount_locked(channel_state.our_state)
message_identifier = random.randint(0, UINT64_MAX)
payment_identifier = nonce
mediated_transfer_msg = DirectTransfer(
message_identifier,
payment_identifier,
nonce,
registry_address,
channel_state.token_address,
channel_state.identifier,
transferred_amount,
locked_amount,
channel_state.partner_state.address,
locksroot,
)
mediated_transfer_msg.sign(privkey, address)
balance_proof = balanceproof_from_envelope(mediated_transfer_msg)
receive_directtransfer = ReceiveTransferDirect(
payment_network_identifier,
channel_state.token_address,
message_identifier,
payment_identifier,
balance_proof,
)
return receive_directtransfer
def test_new_end_state():
"""Test the defaults for an end state object."""
balance1 = 101
node_address = factories.make_address()
end_state = NettingChannelEndState(node_address, balance1)
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
assert channel.is_lock_pending(end_state, lock_secrethash) is False
assert channel.is_lock_locked(end_state, lock_secrethash) is False
assert channel.get_next_nonce(end_state) == 1
assert channel.get_amount_locked(end_state) == 0
assert not channel.get_known_unlocks(end_state)
assert merkleroot(end_state.merkletree) == EMPTY_MERKLE_ROOT
assert not end_state.secrethashes_to_lockedlocks
assert not end_state.secrethashes_to_unlockedlocks
