def test_python_channel():
netting_channel = NettingChannelMock()
token_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = make_address()
balance1 = 70
balance2 = 110
reveal_timeout = 5
settle_timeout = 15
our_state = ChannelEndState(address1, balance1, netting_channel.opened)
partner_state = ChannelEndState(address2, balance2, netting_channel.opened)
external_state = make_external_state()
test_channel = Channel(
our_state,
partner_state,
external_state,
token_address,
reveal_timeout,
settle_timeout,
)
assert test_channel.contract_balance == our_state.contract_balance
assert test_channel.balance == our_state.balance(partner_state)
assert test_channel.transferred_amount == our_state.transferred_amount
assert test_channel.distributable == our_state.distributable(partner_state)
assert test_channel.outstanding == our_state.locked()
assert test_channel.outstanding == 0
assert test_channel.locked == partner_state.locked()
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
with pytest.raises(ValueError):
test_channel.create_directtransfer(
-10,
1 # TODO: fill in identifier
)
with pytest.raises(ValueError):
test_channel.create_directtransfer(
balance1 + 10,
1 # TODO: fill in identifier
)
amount1 = 10
directtransfer = test_channel.create_directtransfer(
amount1,
1 # TODO: fill in identifier
)
directtransfer.sign(privkey1, address1)
test_channel.register_transfer(directtransfer)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1
assert test_channel.transferred_amount == amount1
assert test_channel.distributable == balance1 - amount1
assert test_channel.outstanding == 0
assert test_channel.locked == 0
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
secret = sha3('test_channel')
hashlock = sha3(secret)
amount2 = 10
fee = 0
expiration = settle_timeout - 5
mediatedtransfer = test_channel.create_mediatedtransfer(
address1,
address2,
fee,
amount2,
1, # TODO: fill in identifier
expiration,
hashlock,
)
mediatedtransfer.sign(privkey1, address1)
test_channel.register_transfer(mediatedtransfer)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1
assert test_channel.transferred_amount == amount1
assert test_channel.distributable == balance1 - amount1 - amount2
assert test_channel.outstanding == 0
assert test_channel.locked == amount2
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == amount2
test_channel.release_lock(secret)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1 - amount2
assert test_channel.transferred_amount == amount1 + amount2
assert test_channel.distributable == balance1 - amount1 - amount2
assert test_channel.outstanding == 0
assert test_channel.locked == 0
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
def test_end_state():
netting_channel = NettingChannelMock()
token_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = 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, netting_channel.opened)
state2 = ChannelEndState(address2, balance2, netting_channel.opened)
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
assert state2.distributable(state1) == balance2
assert state1.locked() == 0
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == ''
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, # TODO: fill in identifier
nonce=state1.nonce,
token=token_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)
state2.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.locked() == 0
assert state2.locked() == lock_amount
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is True
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == lock_hash
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.locked() == 0
assert state2.locked() == lock_amount
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is True
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == lock_hash
# registering the secret should not change the locked amount
state2.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.distributable(state2) == balance1 - lock_amount + 10
assert state2.distributable(state1) == balance2
assert state1.locked() == 0
assert state2.locked() == lock_amount
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == lock_hash
state2.release_lock(state1, lock_secret)
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.locked() == 0
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == ''
def test_end_state():
asset_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = 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)
state2 = ChannelEndState(address2, balance2)
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
assert state2.distributable(state1) == balance2
assert state1.locked() == 0
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == ''
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, # TODO: fill in identifier
nonce=state1.nonce,
asset=asset_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)
state2.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.locked() == 0
assert state2.locked() == lock_amount
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is True
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == lock_hash
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.locked() == 0
assert state2.locked() == lock_amount
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is True
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == lock_hash
# registering the secret should not change the locked amount
state2.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.distributable(state2) == balance1 - lock_amount + 10
assert state2.distributable(state1) == balance2
assert state1.locked() == 0
assert state2.locked() == lock_amount
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == lock_hash
state2.release_lock(state1, lock_secret)
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.locked() == 0
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == ''
assert state2.balance_proof.merkleroot_for_unclaimed() == ''
def test_python_channel():
asset_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = make_address()
balance1 = 70
balance2 = 110
reveal_timeout = 5
settle_timeout = 15
our_state = ChannelEndState(address1, balance1)
partner_state = ChannelEndState(address2, balance2)
external_state = make_external_state()
test_channel = Channel(
our_state, partner_state, external_state,
asset_address, reveal_timeout, settle_timeout,
)
assert test_channel.contract_balance == our_state.contract_balance
assert test_channel.balance == our_state.balance(partner_state)
assert test_channel.transferred_amount == our_state.transferred_amount
assert test_channel.distributable == our_state.distributable(partner_state)
assert test_channel.outstanding == our_state.locked()
assert test_channel.outstanding == 0
assert test_channel.locked == partner_state.locked()
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
with pytest.raises(ValueError):
test_channel.create_directtransfer(
-10,
1 # TODO: fill in identifier
)
with pytest.raises(ValueError):
test_channel.create_directtransfer(
balance1 + 10,
1 # TODO: fill in identifier
)
amount1 = 10
directtransfer = test_channel.create_directtransfer(
amount1,
1 # TODO: fill in identifier
)
directtransfer.sign(privkey1, address1)
test_channel.register_transfer(directtransfer)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1
assert test_channel.transferred_amount == amount1
assert test_channel.distributable == balance1 - amount1
assert test_channel.outstanding == 0
assert test_channel.locked == 0
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
secret = sha3('test_channel')
hashlock = sha3(secret)
amount2 = 10
fee = 0
expiration = settle_timeout - 5
mediatedtransfer = test_channel.create_mediatedtransfer(
address1,
address2,
fee,
amount2,
1, # TODO: fill in identifier
expiration,
hashlock,
)
mediatedtransfer.sign(privkey1, address1)
test_channel.register_transfer(mediatedtransfer)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1
assert test_channel.transferred_amount == amount1
assert test_channel.distributable == balance1 - amount1 - amount2
assert test_channel.outstanding == 0
assert test_channel.locked == amount2
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == amount2
test_channel.release_lock(secret)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1 - amount2
assert test_channel.transferred_amount == amount1 + amount2
assert test_channel.distributable == balance1 - amount1 - amount2
assert test_channel.outstanding == 0
assert test_channel.locked == 0
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
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, BalanceProof(None))
state2 = ChannelEndState(address2, balance2, BalanceProof(None))
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
assert state2.distributable(state1) == balance2
assert state1.locked() == 0
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == EMPTY_MERKLE_ROOT
assert state2.balance_proof.merkleroot_for_unclaimed() == 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.locked() == lock_amount
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is True
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == lock_hash
assert state2.balance_proof.merkleroot_for_unclaimed() == 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.locked() == lock_amount
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is True
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == lock_hash
assert state2.balance_proof.merkleroot_for_unclaimed() == 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.distributable(state2) == balance1 - lock_amount + 10
assert state2.distributable(state1) == balance2
assert state1.locked() == lock_amount
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == lock_hash
assert state2.balance_proof.merkleroot_for_unclaimed() == 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.locked() == 0
assert state2.locked() == 0
assert state1.balance_proof.is_pending(lock_hashlock) is False
assert state2.balance_proof.is_pending(lock_hashlock) is False
assert state1.balance_proof.merkleroot_for_unclaimed() == EMPTY_MERKLE_ROOT
assert state2.balance_proof.merkleroot_for_unclaimed() == EMPTY_MERKLE_ROOT
assert state1.nonce is 2
assert state2.nonce is None
def test_python_channel():
token_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = make_address()
balance1 = 70
balance2 = 110
reveal_timeout = 5
settle_timeout = 15
block_number = 10
our_state = ChannelEndState(address1, balance1, BalanceProof(None))
partner_state = ChannelEndState(address2, balance2, BalanceProof(None))
external_state = make_external_state()
test_channel = Channel(
our_state,
partner_state,
external_state,
token_address,
reveal_timeout,
settle_timeout,
)
assert test_channel.contract_balance == our_state.contract_balance
assert test_channel.balance == our_state.balance(partner_state)
assert test_channel.transferred_amount == our_state.transferred_amount
assert test_channel.distributable == our_state.distributable(partner_state)
assert test_channel.outstanding == our_state.locked()
assert test_channel.outstanding == 0
assert test_channel.locked == partner_state.locked()
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
assert test_channel.get_next_nonce() == 1
with pytest.raises(ValueError):
test_channel.create_directtransfer(
-10,
identifier=1,
)
with pytest.raises(ValueError):
test_channel.create_directtransfer(
balance1 + 10,
identifier=1,
)
amount1 = 10
directtransfer = test_channel.create_directtransfer(
amount1,
identifier=1,
)
directtransfer.sign(privkey1, address1)
test_channel.register_transfer(
block_number,
directtransfer,
)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1
assert test_channel.transferred_amount == amount1
assert test_channel.distributable == balance1 - amount1
assert test_channel.outstanding == 0
assert test_channel.locked == 0
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
assert test_channel.get_next_nonce() == 2
secret = sha3('test_channel')
hashlock = sha3(secret)
amount2 = 10
fee = 0
expiration = block_number + settle_timeout - 5
identifier = 1
mediatedtransfer = test_channel.create_mediatedtransfer(
address1,
address2,
fee,
amount2,
identifier,
expiration,
hashlock,
)
mediatedtransfer.sign(privkey1, address1)
test_channel.register_transfer(
block_number,
mediatedtransfer,
)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1
assert test_channel.transferred_amount == amount1
assert test_channel.distributable == balance1 - amount1 - amount2
assert test_channel.outstanding == 0
assert test_channel.locked == amount2
assert test_channel.our_state.locked() == amount2
assert test_channel.partner_state.locked() == 0
assert test_channel.get_next_nonce() == 3
secret_message = test_channel.create_secret(identifier, secret)
secret_message.sign(privkey1, address1)
test_channel.register_transfer(block_number, secret_message)
assert test_channel.contract_balance == balance1
assert test_channel.balance == balance1 - amount1 - amount2
assert test_channel.transferred_amount == amount1 + amount2
assert test_channel.distributable == balance1 - amount1 - amount2
assert test_channel.outstanding == 0
assert test_channel.locked == 0
assert test_channel.our_state.locked() == 0
assert test_channel.partner_state.locked() == 0
assert test_channel.get_next_nonce() == 4
def test_channel():
class NettingChannelMock(object):
def opened(self):
return 1
def closed(self):
return 0
def settled(self):
return 0
asset_address = make_address()
privkey1, address1 = make_privkey_address()
address2 = make_address()
balance1 = 70
balance2 = 110
reveal_timeout = 5
settle_timeout = 15
our_state = ChannelEndState(address1, balance1)
partner_state = ChannelEndState(address2, balance2)
block_alarm = list()
channel_for_hashlock = list()
netting_channel = NettingChannelMock()
external_state = ChannelExternalState(
block_alarm.append,
lambda *args: channel_for_hashlock.append(args),
lambda: 1,
netting_channel,
)
channel = Channel(
our_state,
partner_state,
external_state,
asset_address,
reveal_timeout,
settle_timeout,
)
assert channel.contract_balance == our_state.contract_balance
assert channel.balance == our_state.balance(partner_state)
assert channel.transfered_amount == our_state.transfered_amount
assert channel.distributable == our_state.distributable(partner_state)
assert channel.outstanding == our_state.locked()
assert channel.outstanding == 0
assert channel.locked == partner_state.locked()
assert channel.our_state.locked() == 0
assert channel.partner_state.locked() == 0
with pytest.raises(ValueError):
channel.create_directtransfer(-10)
with pytest.raises(ValueError):
channel.create_directtransfer(balance1 + 10)
amount1 = 10
directtransfer = channel.create_directtransfer(amount1)
directtransfer.sign(privkey1, address1)
channel.register_transfer(directtransfer)
assert channel.contract_balance == balance1
assert channel.balance == balance1 - amount1
assert channel.transfered_amount == amount1
assert channel.distributable == balance1 - amount1
assert channel.outstanding == 0
assert channel.locked == 0
assert channel.our_state.locked() == 0
assert channel.partner_state.locked() == 0
secret = sha3('test_channel')
hashlock = sha3(secret)
amount2 = 10
fee = 0
expiration = settle_timeout - 5
mediatedtransfer = channel.create_mediatedtransfer(
address1,
address2,
fee,
amount2,
expiration,
hashlock,
)
mediatedtransfer.sign(privkey1, address1)
channel.register_transfer(mediatedtransfer)
assert channel.contract_balance == balance1
assert channel.balance == balance1 - amount1
assert channel.transfered_amount == amount1
assert channel.distributable == balance1 - amount1 - amount2
assert channel.outstanding == 0
assert channel.locked == amount2
assert channel.our_state.locked() == 0
assert channel.partner_state.locked() == amount2
channel.claim_lock(secret)
assert channel.contract_balance == balance1
assert channel.balance == balance1 - amount1 - amount2
assert channel.transfered_amount == amount1 + amount2
assert channel.distributable == balance1 - amount1 - amount2
assert channel.outstanding == 0
assert channel.locked == 0
assert channel.our_state.locked() == 0
assert channel.partner_state.locked() == 0
