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