def make_receive_expired_lock(
channel_state: NettingChannelState,
privkey: bytes,
nonce: Nonce,
transferred_amount: TokenAmount,
lock: HashTimeLockState,
locked_amount: LockedAmount,
pending_locks: PendingLocksState = None,
chain_id: ChainID = None,
) -> ReceiveLockExpired:
typecheck(lock, HashTimeLockState)
signer = LocalSigner(privkey)
address = signer.address
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 pending_locks is None:
pending_locks = make_empty_pending_locks_state()
else:
assert lock.encoded not in pending_locks.locks
locksroot = compute_locksroot(pending_locks)
chain_id = chain_id or channel_state.chain_id
lock_expired_msg = LockExpired(
chain_id=chain_id,
nonce=nonce,
message_identifier=make_message_identifier(),
transferred_amount=transferred_amount,
locked_amount=TokenAmount(locked_amount),
locksroot=locksroot,
channel_identifier=channel_state.identifier,
token_network_address=channel_state.token_network_address,
recipient=channel_state.partner_state.address,
secrethash=lock.secrethash,
signature=EMPTY_SIGNATURE,
)
lock_expired_msg.sign(signer)
balance_proof = balanceproof_from_envelope(lock_expired_msg)
receive_lockedtransfer = ReceiveLockExpired(
balance_proof=balance_proof,
secrethash=lock.secrethash,
message_identifier=make_message_identifier(),
sender=balance_proof.sender,
)
return receive_lockedtransfer
def assert_locked(from_channel: NettingChannelState,
pending_locks: List[HashTimeLockState]) -> None:
""" Assert the locks created from `from_channel`. """
# a locked transfer is registered in the _partner_ state
if pending_locks:
locks = PendingLocksState([lock.encoded for lock in pending_locks])
else:
locks = make_empty_pending_locks_state()
assert from_channel.our_state.pending_locks == locks
for lock in pending_locks:
pending = lock.secrethash in from_channel.our_state.secrethashes_to_lockedlocks
unclaimed = lock.secrethash in from_channel.our_state.secrethashes_to_unlockedlocks
assert pending or unclaimed
def __init__(self, canonical_identifier):
self._canonical_identifier = canonical_identifier
self._pending_locks = make_empty_pending_locks_state()
self.properties = None
def make_receive_transfer_mediated(
channel_state: NettingChannelState,
privkey: bytes,
nonce: Nonce,
transferred_amount: TokenAmount,
lock: HashTimeLockState,
pending_locks: PendingLocksState = None,
locked_amount: Optional[PaymentWithFeeAmount] = None,
chain_id: Optional[ChainID] = None,
) -> LockedTransferSignedState:
typecheck(lock, HashTimeLockState)
signer = LocalSigner(privkey)
address = signer.address
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 pending_locks is None:
locks = make_empty_pending_locks_state()
locks.locks.append(lock.encoded)
else:
assert bytes(lock.encoded) in pending_locks.locks
locks = pending_locks
if locked_amount is None:
locked_amount = lock.amount
assert locked_amount >= lock.amount
locksroot = compute_locksroot(locks)
payment_identifier = PaymentID(nonce)
transfer_target = make_target_address()
transfer_initiator = make_initiator_address()
chain_id = chain_id or channel_state.chain_id
transfer_metadata = Metadata(routes=[
RouteMetadata(
route=[channel_state.our_state.address,
Address(transfer_target)])
])
mediated_transfer_msg = LockedTransfer(
chain_id=chain_id,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=nonce,
token_network_address=channel_state.token_network_address,
token=channel_state.token_address,
channel_identifier=channel_state.identifier,
transferred_amount=transferred_amount,
locked_amount=TokenAmount(locked_amount),
recipient=channel_state.partner_state.address,
locksroot=locksroot,
lock=Lock(amount=lock.amount,
expiration=lock.expiration,
secrethash=lock.secrethash),
target=transfer_target,
initiator=transfer_initiator,
signature=EMPTY_SIGNATURE,
fee=0,
metadata=transfer_metadata,
)
mediated_transfer_msg.sign(signer)
receive_lockedtransfer = LockedTransferSignedState(
payment_identifier=payment_identifier,
token=channel_state.token_address,
lock=lock,
initiator=transfer_initiator,
target=transfer_target,
message_identifier=make_message_identifier(),
balance_proof=balanceproof_from_envelope(mediated_transfer_msg),
routes=[
route_metadata.route for route_metadata in transfer_metadata.routes
],
)
return receive_lockedtransfer
