def make_receive_transfer_mediated(
channel_state,
privkey,
nonce,
transferred_amount,
lock,
merkletree_leaves=None):
if not isinstance(lock, HashTimeLockState):
raise ValueError('lock must be of type HashTimeLockState')
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 merkletree_leaves is None:
layers = [[lock.lockhash]]
else:
assert lock.lockhash in merkletree_leaves
layers = compute_layers(merkletree_leaves)
locksroot = layers[MERKLEROOT][0]
message_identifier = random.randint(0, UINT64_MAX)
payment_identifier = nonce
transfer_target = factories.make_address()
transfer_initiator = factories.make_address()
mediated_transfer_msg = LockedTransfer(
message_identifier,
payment_identifier,
nonce,
channel_state.token_address,
channel_state.identifier,
transferred_amount,
channel_state.partner_state.address,
locksroot,
lock,
transfer_target,
transfer_initiator,
)
mediated_transfer_msg.sign(privkey, address)
balance_proof = balanceproof_from_envelope(mediated_transfer_msg)
receive_lockedtransfer = LockedTransferSignedState(
payment_identifier,
channel_state.token_address,
balance_proof,
lock,
transfer_initiator,
transfer_target,
)
return receive_lockedtransfer
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 make_receive_transfer_mediated(
channel_state,
privkey,
nonce,
transferred_amount,
lock,
merkletree_leaves=None,
token_network_address=UNIT_REGISTRY_IDENTIFIER,
locked_amount=None,
chain_id=UNIT_CHAIN_ID,
):
if not isinstance(lock, HashTimeLockState):
raise ValueError('lock must be of type HashTimeLockState')
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 merkletree_leaves is None:
layers = [[lock.lockhash]]
else:
assert lock.lockhash in merkletree_leaves
layers = compute_layers(merkletree_leaves)
if locked_amount is None:
locked_amount = lock.amount
assert locked_amount >= lock.amount
locksroot = layers[MERKLEROOT][0]
payment_identifier = nonce
transfer_target = make_address()
transfer_initiator = make_address()
mediated_transfer_msg = LockedTransfer(
chain_id=chain_id,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
nonce=nonce,
token_network_address=token_network_address,
token=channel_state.token_address,
channel_identifier=channel_state.identifier,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
recipient=channel_state.partner_state.address,
locksroot=locksroot,
lock=lock,
target=transfer_target,
initiator=transfer_initiator,
)
mediated_transfer_msg.sign(privkey)
balance_proof = balanceproof_from_envelope(mediated_transfer_msg)
receive_lockedtransfer = LockedTransferSignedState(
random.randint(0, UINT64_MAX),
payment_identifier,
channel_state.token_address,
balance_proof,
lock,
transfer_initiator,
transfer_target,
)
return receive_lockedtransfer
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
def make_receive_transfer_mediated(
channel_state: NettingChannelState,
privkey: bytes,
nonce: Nonce,
transferred_amount: TokenAmount,
lock: HashTimeLockState,
merkletree_leaves: List[Keccak256] = None,
locked_amount: Optional[LockedAmount] = None,
chain_id: Optional[ChainID] = None,
) -> LockedTransferSignedState:
if not isinstance(lock, HashTimeLockState):
raise ValueError("lock must be of type 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 merkletree_leaves is None:
layers = [[lock.lockhash]]
else:
assert lock.lockhash in merkletree_leaves
layers = compute_layers(merkletree_leaves)
if locked_amount is None:
locked_amount = lock.amount
assert locked_amount >= lock.amount
locksroot = layers[MERKLEROOT][0]
payment_identifier = nonce
payment_hash_invoice = make_payment_hash_invoice()
transfer_target = make_address()
transfer_initiator = make_address()
chain_id = chain_id or channel_state.chain_id
mediated_transfer_msg = LockedTransfer(
chain_id=chain_id,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=payment_identifier,
payment_hash_invoice=payment_hash_invoice,
nonce=nonce,
token_network_address=channel_state.token_network_identifier,
token=channel_state.token_address,
channel_identifier=channel_state.identifier,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
recipient=channel_state.partner_state.address,
locksroot=locksroot,
lock=lock,
target=transfer_target,
initiator=transfer_initiator,
)
mediated_transfer_msg.sign(signer)
balance_proof = balanceproof_from_envelope(mediated_transfer_msg)
receive_lockedtransfer = LockedTransferSignedState(
random.randint(0, UINT64_MAX),
payment_identifier,
payment_hash_invoice,
channel_state.token_address,
balance_proof,
lock,
transfer_initiator,
transfer_target,
)
return receive_lockedtransfer