def pending_mediated_transfer(app_chain, token, amount, identifier):
""" Nice to read shortcut to make a MediatedTransfer where the secret is _not_ revealed.
While the secret is not revealed all apps will be synchronized, meaning
they are all going to receive the MediatedTransfer message.
Returns:
The secret used to generate the MediatedTransfer
"""
# pylint: disable=too-many-locals
if len(app_chain) < 2:
raise ValueError(
'Cannot make a MediatedTransfer with less than two apps')
target = app_chain[-1].raiden.address
# Generate a secret
initiator_channel = get_channelstate(app_chain[0], app_chain[1], token)
address = initiator_channel.identifier
nonce_int = channel.get_next_nonce(initiator_channel.our_state)
nonce_bytes = nonce_int.to_bytes(2, 'big')
secret = sha3(address + nonce_bytes)
initiator_app = app_chain[0]
init_initiator_statechange = initiator_init(
initiator_app.raiden,
identifier,
amount,
secret,
token,
target,
)
events = initiator_app.raiden.wal.log_and_dispatch(
init_initiator_statechange,
initiator_app.raiden.get_block_number(),
)
send_transfermessage = must_contain_entry(events, SendMediatedTransfer, {})
transfermessage = MediatedTransfer.from_event(send_transfermessage)
initiator_app.raiden.sign(transfermessage)
for mediator_app in app_chain[1:-1]:
mediator_init_statechange = mediator_init(mediator_app.raiden,
transfermessage)
events = mediator_app.raiden.wal.log_and_dispatch(
mediator_init_statechange,
mediator_app.raiden.get_block_number(),
)
send_transfermessage = must_contain_entry(events, SendMediatedTransfer,
{})
transfermessage = MediatedTransfer.from_event(send_transfermessage)
mediator_app.raiden.sign(transfermessage)
target_app = app_chain[-1]
mediator_init_statechange = target_init(target_app.raiden, transfermessage)
events = target_app.raiden.wal.log_and_dispatch(
mediator_init_statechange,
target_app.raiden.get_block_number(),
)
return secret
def handle_send_mediatedtransfer(
raiden: 'RaidenService',
send_mediated_transfer: SendMediatedTransfer):
mediated_transfer_message = MediatedTransfer.from_event(send_mediated_transfer)
raiden.sign(mediated_transfer_message)
raiden.send_async(
mediated_transfer_message.recipient,
mediated_transfer_message,
)
def make_mediated_transfer(
from_channel,
partner_channel,
initiator,
target,
lock,
pkey,
secret=None
):
""" Helper to create and register a mediated transfer from `from_channel` to
`partner_channel`."""
identifier = channel.get_next_nonce(from_channel.our_state)
mediatedtransfer = channel.send_mediatedtransfer(
from_channel,
initiator,
target,
lock.amount,
identifier,
lock.expiration,
lock.hashlock,
)
mediated_transfer_msg = MediatedTransfer.from_event(mediatedtransfer)
address = privatekey_to_address(pkey)
sign_key = PrivateKey(pkey)
mediated_transfer_msg.sign(sign_key, address)
# compute the signature
balance_proof = balanceproof_from_envelope(mediated_transfer_msg)
mediatedtransfer.balance_proof = balance_proof
# if this fails it's not the right key for the current `from_channel`
assert mediated_transfer_msg.sender == from_channel.our_state.address
receive_mediatedtransfer = lockedtransfersigned_from_message(mediated_transfer_msg)
channel.handle_receive_mediatedtransfer(
partner_channel,
receive_mediatedtransfer,
)
if secret is not None:
random_sender = make_address()
from_secretreveal = ReceiveSecretReveal(secret, random_sender)
channel.handle_receive_secretreveal(from_channel, from_secretreveal)
partner_secretreveal = ReceiveSecretReveal(secret, random_sender)
channel.handle_receive_secretreveal(partner_channel, partner_secretreveal)
return mediated_transfer_msg
