def _(properties, defaults=None) -> LockedTransferSignedState: defaults = defaults or LOCKED_TRANSFER_SIGNED_STATE_DEFAULTS params = _properties_to_dict(properties, defaults) transfer_params = _properties_to_dict(params.pop('transfer'), defaults.transfer) balance_proof_params = _properties_to_dict( transfer_params.pop('balance_proof'), defaults.transfer.balance_proof, ) lock = Lock( amount=transfer_params.pop('amount'), expiration=transfer_params.pop('expiration'), secrethash=sha3(transfer_params.pop('secret')), ) pkey = params.pop('pkey') sender = params.pop('sender') params.update(transfer_params) params.update(balance_proof_params) params['token_network_address'] = params.pop('token_network_identifier') if params['locksroot'] == EMPTY_MERKLE_ROOT: params['locksroot'] = lock.lockhash locked_transfer = LockedTransfer(lock=lock, **params) locked_transfer.sign(pkey) assert locked_transfer.sender == sender return lockedtransfersigned_from_message(locked_transfer)
def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer): token_network_address = message.token_network_address from_transfer = lockedtransfersigned_from_message(message) chain_state = views.state_from_raiden(raiden) routes = get_best_routes( chain_state, token_network_address, raiden.address, from_transfer.target, from_transfer.lock.amount, message.sender, ) role = views.get_transfer_role( chain_state, from_transfer.lock.secrethash, ) if role == 'initiator': secret = random_secret() state_change = ReceiveTransferRefundCancelRoute( message.sender, routes, from_transfer, secret, ) else: state_change = ReceiveTransferRefund( message.sender, from_transfer, routes, ) raiden.handle_state_change(state_change)
def handle_message_refundtransfer(self, raiden: RaidenService, message: RefundTransfer): token_network_address = message.token_network_address from_transfer = lockedtransfersigned_from_message(message) chain_state = views.state_from_raiden(raiden) routes = get_best_routes( chain_state, token_network_address, raiden.address, from_transfer.target, from_transfer.lock.amount, message.sender, ) role = views.get_transfer_role( chain_state, from_transfer.lock.secrethash, ) if role == 'initiator': secret = random_secret() state_change = ReceiveTransferRefundCancelRoute( routes=routes, transfer=from_transfer, secret=secret, ) else: state_change = ReceiveTransferRefund( transfer=from_transfer, routes=routes, ) raiden.handle_state_change(state_change)
def _(properties, defaults=None) -> LockedTransferSignedState: defaults = defaults or LOCKED_TRANSFER_SIGNED_STATE_DEFAULTS params = _properties_to_dict(properties, defaults) transfer_params = _properties_to_dict(params.pop('transfer'), defaults.transfer) balance_proof_params = _properties_to_dict( transfer_params.pop('balance_proof'), defaults.transfer.balance_proof, ) lock = Lock( amount=transfer_params.pop('amount'), expiration=transfer_params.pop('expiration'), secrethash=sha3(transfer_params.pop('secret')), ) pkey = params.pop('pkey') signer = LocalSigner(pkey) sender = params.pop('sender') params.update(transfer_params) params.update(balance_proof_params) params['token_network_address'] = params.pop('token_network_identifier') if params['locksroot'] == EMPTY_MERKLE_ROOT: params['locksroot'] = lock.lockhash locked_transfer = LockedTransfer(lock=lock, **params) locked_transfer.sign(signer) assert locked_transfer.sender == sender return lockedtransfersigned_from_message(locked_transfer)
def _(properties, defaults=None) -> LockedTransferSignedState: transfer: LockedTransferSignedStateProperties = create_properties( properties, defaults) params = {key: value for key, value in transfer.__dict__.items()} lock = Lock(amount=transfer.amount, expiration=transfer.expiration, secrethash=sha3(transfer.secret)) pkey = params.pop("pkey") signer = LocalSigner(pkey) sender = params.pop("sender") canonical_identifier = params.pop("canonical_identifier") params["chain_id"] = int(canonical_identifier.chain_identifier) params["channel_identifier"] = int(canonical_identifier.channel_identifier) params[ "token_network_address"] = canonical_identifier.token_network_address if params["locksroot"] == EMPTY_MERKLE_ROOT: params["locksroot"] = lock.lockhash locked_transfer = LockedTransfer(lock=lock, **params) locked_transfer.sign(signer) assert locked_transfer.sender == sender return lockedtransfersigned_from_message(locked_transfer)
def make_signed_transfer( amount, initiator, target, expiration, secret, payment_identifier=1, message_identifier=None, nonce=1, transferred_amount=0, locked_amount=None, locksroot=EMPTY_MERKLE_ROOT, recipient=UNIT_TRANSFER_TARGET, channel_identifier=UNIT_CHANNEL_ID, token_network_address=UNIT_TOKEN_NETWORK_ADDRESS, token=UNIT_TOKEN_ADDRESS, pkey=UNIT_TRANSFER_PKEY, sender=UNIT_TRANSFER_SENDER, ): if message_identifier is None: message_identifier = random.randint(0, UINT64_MAX) secrethash = sha3(secret) lock = Lock( amount, expiration, secrethash, ) if locksroot == EMPTY_MERKLE_ROOT: locksroot = sha3(lock.as_bytes) if locked_amount is None: locked_amount = amount else: assert locked_amount >= amount transfer = LockedTransfer( chain_id=UNIT_CHAIN_ID, message_identifier=message_identifier, payment_identifier=payment_identifier, nonce=nonce, token_network_address=token_network_address, token=token, channel_identifier=channel_identifier, transferred_amount=transferred_amount, locked_amount=locked_amount, recipient=recipient, locksroot=locksroot, lock=lock, target=target, initiator=initiator, ) transfer.sign(pkey) assert transfer.sender == sender return lockedtransfersigned_from_message(transfer)
def make_signed_transfer( amount, initiator, target, expiration, secret, payment_identifier=1, message_identifier=None, nonce=1, transferred_amount=0, locked_amount=None, locksroot=EMPTY_MERKLE_ROOT, recipient=UNIT_TRANSFER_TARGET, channel_identifier=UNIT_CHANNEL_ID, token=UNIT_TOKEN_ADDRESS, pkey=UNIT_TRANSFER_PKEY, sender=UNIT_TRANSFER_SENDER, ): if message_identifier is None: message_identifier = random.randint(0, UINT64_MAX) secrethash = sha3(secret) lock = Lock( amount, expiration, secrethash, ) if locksroot == EMPTY_MERKLE_ROOT: locksroot = sha3(lock.as_bytes) if locked_amount is None: locked_amount = amount else: assert locked_amount >= amount transfer = LockedTransfer( chain_id=UNIT_CHAIN_ID, message_identifier=message_identifier, payment_identifier=payment_identifier, nonce=nonce, token_network_address=UNIT_TOKEN_NETWORK_ADDRESS, token=token, channel_identifier=channel_identifier, transferred_amount=transferred_amount, locked_amount=locked_amount, recipient=recipient, locksroot=locksroot, lock=lock, target=target, initiator=initiator, ) transfer.sign(pkey) assert transfer.sender == sender return lockedtransfersigned_from_message(transfer)
def make_mediated_transfer(registry_address, from_channel, partner_channel, initiator, target, lock, pkey, secret=None): """ Helper to create and register a mediated transfer from `from_channel` to `partner_channel`.""" payment_identifier = channel.get_next_nonce(from_channel.our_state) message_identifier = random.randint(0, UINT64_MAX) lockedtransfer = channel.send_lockedtransfer( registry_address, from_channel, initiator, target, lock.amount, message_identifier, payment_identifier, lock.expiration, lock.secrethash, ) mediated_transfer_msg = LockedTransfer.from_event(lockedtransfer) 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) lockedtransfer.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_lockedtransfer = lockedtransfersigned_from_message( mediated_transfer_msg) channel.handle_receive_lockedtransfer( partner_channel, receive_lockedtransfer, ) 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
def target_init(transfer: LockedTransfer): from_transfer = lockedtransfersigned_from_message(transfer) from_route = RouteState( transfer.sender, from_transfer.balance_proof.channel_address, ) init_target_statechange = ActionInitTarget( from_route, from_transfer, ) return init_target_statechange
def target_init(transfer: LockedTransfer): from_transfer = lockedtransfersigned_from_message(transfer) from_route = RouteState( transfer.sender, from_transfer.balance_proof.channel_identifier, ) init_target_statechange = ActionInitTarget( from_route, from_transfer, ) return init_target_statechange
def make_signed_transfer( amount, initiator, target, expiration, secret, payment_identifier=1, message_identifier=None, nonce=1, transferred_amount=0, locked_amount=None, recipient=UNIT_TRANSFER_TARGET, channel_identifier=UNIT_CHANNEL_ADDRESS, token=UNIT_TOKEN_ADDRESS, pkey=UNIT_TRANSFER_PKEY, sender=UNIT_TRANSFER_SENDER, ): if message_identifier is None: message_identifier = random.randint(0, UINT64_MAX) secrethash = sha3(secret) lock = Lock( amount, expiration, secrethash, ) if locked_amount is None: locked_amount = amount else: assert locked_amount >= amount transfer = LockedTransfer( message_identifier, payment_identifier, nonce, UNIT_REGISTRY_IDENTIFIER, token, channel_identifier, transferred_amount, locked_amount, recipient, lock.lockhash, lock, target, initiator, ) transfer.sign(pkey) assert transfer.sender == sender return lockedtransfersigned_from_message(transfer)
def target_init(raiden, transfer): from_transfer = lockedtransfersigned_from_message(transfer) from_route = RouteState2( transfer.sender, from_transfer.balance_proof.channel_address, ) registry_address = raiden.default_registry.address init_target_statechange = ActionInitTarget2( registry_address, from_route, from_transfer, ) return init_target_statechange
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`.""" payment_identifier = channel.get_next_nonce(from_channel.our_state) message_identifier = random.randint(0, UINT64_MAX) lockedtransfer = channel.send_lockedtransfer( from_channel, initiator, target, lock.amount, message_identifier, payment_identifier, lock.expiration, lock.secrethash, ) mediated_transfer_msg = LockedTransfer.from_event(lockedtransfer) sign_key = PrivateKey(pkey) mediated_transfer_msg.sign(sign_key) # compute the signature balance_proof = balanceproof_from_envelope(mediated_transfer_msg) lockedtransfer.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_lockedtransfer = lockedtransfersigned_from_message(mediated_transfer_msg) channel.handle_receive_lockedtransfer( partner_channel, receive_lockedtransfer, ) if secret is not None: secrethash = sha3(secret) channel.register_secret(from_channel, secret, secrethash) channel.register_secret(partner_channel, secret, secrethash) return mediated_transfer_msg
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`.""" payment_identifier = channel.get_next_nonce(from_channel.our_state) message_identifier = random.randint(0, UINT64_MAX) lockedtransfer = channel.send_lockedtransfer( from_channel, initiator, target, lock.amount, message_identifier, payment_identifier, lock.expiration, lock.secrethash, ) mediated_transfer_msg = LockedTransfer.from_event(lockedtransfer) sign_key = PrivateKey(pkey) mediated_transfer_msg.sign(sign_key, NETWORKNAME_TO_ID[TESTS]) # compute the signature balance_proof = balanceproof_from_envelope(mediated_transfer_msg) lockedtransfer.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_lockedtransfer = lockedtransfersigned_from_message(mediated_transfer_msg) channel.handle_receive_lockedtransfer( partner_channel, receive_lockedtransfer, ) if secret is not None: secrethash = sha3(secret) channel.register_secret(from_channel, secret, secrethash) channel.register_secret(partner_channel, secret, secrethash) return mediated_transfer_msg
def mediator_init(raiden, transfer: LockedTransfer): from_transfer = lockedtransfersigned_from_message(transfer) routes = routing.get_best_routes( chain_state=views.state_from_raiden(raiden), token_network_id=TokenNetworkID( from_transfer.balance_proof.token_network_identifier), from_address=raiden.address, to_address=from_transfer.target, amount=PaymentAmount(from_transfer.lock.amount ), # FIXME: mypy; deprecated through #3863 previous_address=transfer.sender, config=raiden.config, privkey=raiden.privkey, ) from_route = RouteState(transfer.sender, from_transfer.balance_proof.channel_identifier) init_mediator_statechange = ActionInitMediator(routes, from_route, from_transfer) return init_mediator_statechange
def mediator_init(raiden, transfer: LockedTransfer) -> ActionInitMediator: from_transfer = lockedtransfersigned_from_message(transfer) # Feedback token not used here, will be removed with source routing routes, _ = routing.get_best_routes( chain_state=views.state_from_raiden(raiden), token_network_id=TokenNetworkID( from_transfer.balance_proof.token_network_identifier), one_to_n_address=raiden.default_one_to_n_address, from_address=raiden.address, to_address=from_transfer.target, amount=PaymentAmount(from_transfer.lock.amount ), # FIXME: mypy; deprecated through #3863 previous_address=transfer.sender, config=raiden.config, privkey=raiden.privkey, ) from_route = RouteState(transfer.sender, from_transfer.balance_proof.channel_identifier) return ActionInitMediator(routes, from_route, from_transfer)
def mediator_init(raiden, transfer: LockedTransfer): from_transfer = lockedtransfersigned_from_message(transfer) routes = routing.get_best_routes( views.state_from_raiden(raiden), from_transfer.balance_proof.token_network_identifier, raiden.address, from_transfer.target, from_transfer.lock.amount, transfer.sender, ) from_route = RouteState( transfer.sender, from_transfer.balance_proof.channel_address, ) init_mediator_statechange = ActionInitMediator( routes, from_route, from_transfer, ) return init_mediator_statechange
def mediator_init(raiden, transfer: LockedTransfer): from_transfer = lockedtransfersigned_from_message(transfer) routes = routing.get_best_routes( views.state_from_raiden(raiden), from_transfer.balance_proof.token_network_identifier, raiden.address, from_transfer.target, from_transfer.lock.amount, transfer.sender, ) from_route = RouteState( transfer.sender, from_transfer.balance_proof.channel_address, ) init_mediator_statechange = ActionInitMediator( routes, from_route, from_transfer, ) return init_mediator_statechange
def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer) -> None: token_network_address = message.token_network_address from_transfer = lockedtransfersigned_from_message(message) chain_state = views.state_from_raiden(raiden) # FIXME: Shouldn't request routes here routes, _ = get_best_routes( chain_state=chain_state, token_network_id=TokenNetworkID(token_network_address), one_to_n_address=raiden.default_one_to_n_address, from_address=InitiatorAddress(raiden.address), to_address=from_transfer.target, amount=PaymentAmount( from_transfer.lock.amount), # FIXME: mypy; deprecated by #3863 previous_address=message.sender, config=raiden.config, privkey=raiden.privkey, ) role = views.get_transfer_role( chain_state=chain_state, secrethash=from_transfer.lock.secrethash) state_change: StateChange if role == "initiator": old_secret = views.get_transfer_secret( chain_state, from_transfer.lock.secrethash) # We currently don't allow multi routes if the initiator does not # hold the secret. In such case we remove all other possible routes # which allow the API call to return with with an error message. if old_secret == EMPTY_SECRET: routes = list() secret = random_secret() state_change = ReceiveTransferRefundCancelRoute( routes=routes, transfer=from_transfer, secret=secret) else: state_change = ReceiveTransferRefund(transfer=from_transfer, routes=routes) raiden.handle_and_track_state_change(state_change)
def make_signed_transfer_state( amount: typing.TokenAmount = EMPTY, initiator: typing.InitiatorAddress = EMPTY, target: typing.TargetAddress = EMPTY, expiration: typing.BlockExpiration = EMPTY, secret: typing.Secret = EMPTY, payment_identifier: typing.PaymentID = EMPTY, message_identifier: typing.MessageID = EMPTY, nonce: typing.Nonce = EMPTY, transferred_amount: typing.TokenAmount = EMPTY, locked_amount: typing.TokenAmount = EMPTY, locksroot: typing.Locksroot = EMPTY, recipient: typing.Address = EMPTY, channel_identifier: typing.ChannelID = EMPTY, token_network_address: typing.TokenNetworkID = EMPTY, token: typing.TargetAddress = EMPTY, pkey: bytes = EMPTY, sender: typing.Address = EMPTY, ) -> LockedTransferSignedState: transfer = make_signed_transfer( amount=amount, initiator=initiator, target=target, expiration=expiration, secret=secret, payment_identifier=payment_identifier, message_identifier=message_identifier, nonce=nonce, transferred_amount=transferred_amount, locked_amount=locked_amount, locksroot=locksroot, recipient=recipient, channel_identifier=channel_identifier, token_network_address=token_network_address, token=token, pkey=pkey, sender=sender, ) return lockedtransfersigned_from_message(transfer)
def make_signed_transfer( amount, initiator, target, expiration, secret, identifier=1, nonce=1, transferred_amount=0, recipient=UNIT_TRANSFER_TARGET, channel_identifier=UNIT_CHANNEL_ADDRESS, token=UNIT_TOKEN_ADDRESS, pkey=UNIT_TRANSFER_PKEY, sender=UNIT_TRANSFER_SENDER ): secrethash = sha3(secret) lock = Lock( amount, expiration, secrethash, ) transfer = LockedTransfer( identifier, nonce, token, channel_identifier, transferred_amount, recipient, lock.lockhash, lock, target, initiator, ) transfer.sign(pkey, sender) return lockedtransfersigned_from_message(transfer)
def handle_message_refundtransfer(raiden: 'RaidenService', message: RefundTransfer): registry_address = message.registry_address from_transfer = lockedtransfersigned_from_message(message) node_state = views.state_from_raiden(raiden) routes = get_best_routes( node_state, registry_address, from_transfer.token, raiden.address, from_transfer.target, from_transfer.lock.amount, message.sender, ) role = views.get_transfer_role( node_state, from_transfer.lock.secrethash, ) if role == 'initiator': secret = random_secret() state_change = ReceiveTransferRefundCancelRoute( registry_address, message.sender, routes, from_transfer, secret, ) else: state_change = ReceiveTransferRefund( message.message_identifier, message.sender, from_transfer, ) raiden.handle_state_change(state_change)
def mediator_init(raiden, transfer): from_transfer = lockedtransfersigned_from_message(transfer) registry_address = raiden.default_registry.address routes = routing.get_best_routes( views.state_from_raiden(raiden), registry_address, from_transfer.token, raiden.address, from_transfer.target, from_transfer.lock.amount, transfer.sender, ) from_route = RouteState2( transfer.sender, from_transfer.balance_proof.channel_address, ) init_mediator_statechange = ActionInitMediator2( registry_address, routes, from_route, from_transfer, ) return init_mediator_statechange
def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer): token_network_address = message.token_network_address from_transfer = lockedtransfersigned_from_message(message) chain_state = views.state_from_raiden(raiden) routes = get_best_routes( chain_state=chain_state, token_network_id=TokenNetworkID(token_network_address), from_address=InitiatorAddress(raiden.address), to_address=from_transfer.target, amount=from_transfer.lock.amount, previous_address=message.sender, config=raiden.config, privkey=raiden.privkey, ) role = views.get_transfer_role( chain_state, from_transfer.lock.secrethash, ) state_change: StateChange if role == 'initiator': secret = random_secret() state_change = ReceiveTransferRefundCancelRoute( routes=routes, transfer=from_transfer, secret=secret, ) else: state_change = ReceiveTransferRefund( transfer=from_transfer, routes=routes, ) raiden.handle_and_track_state_change(state_change)
def make_signed_transfer( amount: typing.TokenAmount = EMPTY, initiator: typing.InitiatorAddress = EMPTY, target: typing.TargetAddress = EMPTY, expiration: typing.BlockExpiration = EMPTY, secret: typing.Secret = EMPTY, payment_identifier: typing.PaymentID = EMPTY, message_identifier: typing.MessageID = EMPTY, nonce: typing.Nonce = EMPTY, transferred_amount: typing.TokenAmount = EMPTY, locked_amount: typing.TokenAmount = EMPTY, locksroot: typing.Locksroot = EMPTY, recipient: typing.Address = EMPTY, channel_identifier: typing.ChannelID = EMPTY, token_network_address: typing.TokenNetworkID = EMPTY, token: typing.TargetAddress = EMPTY, pkey: PrivateKey = EMPTY, sender: typing.Address = EMPTY, ) -> LockedTransferSignedState: amount = if_empty(amount, UNIT_TRANSFER_AMOUNT) initiator = if_empty(initiator, make_address()) target = if_empty(target, make_address()) expiration = if_empty(expiration, UNIT_REVEAL_TIMEOUT) secret = if_empty(secret, make_secret()) payment_identifier = if_empty(payment_identifier, 1) message_identifier = if_empty(message_identifier, make_message_identifier()) nonce = if_empty(nonce, 1) transferred_amount = if_empty(transferred_amount, 0) locked_amount = if_empty(locked_amount, amount) locksroot = if_empty(locksroot, EMPTY_MERKLE_ROOT) recipient = if_empty(recipient, UNIT_TRANSFER_TARGET) channel_identifier = if_empty(channel_identifier, UNIT_CHANNEL_ID) token_network_address = if_empty(token_network_address, UNIT_TOKEN_NETWORK_ADDRESS) token = if_empty(token, UNIT_TOKEN_ADDRESS) pkey = if_empty(pkey, UNIT_TRANSFER_PKEY) sender = if_empty(sender, UNIT_TRANSFER_SENDER) assert locked_amount >= amount secrethash = sha3(secret) lock = Lock( amount=amount, expiration=expiration, secrethash=secrethash, ) if locksroot == EMPTY_MERKLE_ROOT: locksroot = sha3(lock.as_bytes) transfer = LockedTransfer( chain_id=UNIT_CHAIN_ID, message_identifier=message_identifier, payment_identifier=payment_identifier, nonce=nonce, token_network_address=token_network_address, token=token, channel_identifier=channel_identifier, transferred_amount=transferred_amount, locked_amount=locked_amount, recipient=recipient, locksroot=locksroot, lock=lock, target=target, initiator=initiator, ) transfer.sign(pkey) assert transfer.sender == sender return lockedtransfersigned_from_message(transfer)
def make_signed_transfer( amount: typing.TokenAmount = EMPTY, initiator: typing.InitiatorAddress = EMPTY, target: typing.TargetAddress = EMPTY, expiration: typing.BlockExpiration = EMPTY, secret: typing.Secret = EMPTY, payment_identifier: typing.PaymentID = EMPTY, message_identifier: typing.MessageID = EMPTY, nonce: typing.Nonce = EMPTY, transferred_amount: typing.TokenAmount = EMPTY, locked_amount: typing.TokenAmount = EMPTY, locksroot: typing.Locksroot = EMPTY, recipient: typing.Address = EMPTY, channel_identifier: typing.ChannelID = EMPTY, token_network_address: typing.TokenNetworkID = EMPTY, token: typing.TargetAddress = EMPTY, pkey: bytes = EMPTY, sender: typing.Address = EMPTY, ) -> LockedTransferSignedState: amount = if_empty(amount, UNIT_TRANSFER_AMOUNT) initiator = if_empty(initiator, make_address()) target = if_empty(target, make_address()) expiration = if_empty(expiration, UNIT_REVEAL_TIMEOUT) secret = if_empty(secret, make_secret()) payment_identifier = if_empty(payment_identifier, 1) message_identifier = if_empty(message_identifier, make_message_identifier()) nonce = if_empty(nonce, 1) transferred_amount = if_empty(transferred_amount, 0) locked_amount = if_empty(locked_amount, amount) locksroot = if_empty(locksroot, EMPTY_MERKLE_ROOT) recipient = if_empty(recipient, UNIT_TRANSFER_TARGET) channel_identifier = if_empty(channel_identifier, UNIT_CHANNEL_ID) token_network_address = if_empty(token_network_address, UNIT_TOKEN_NETWORK_ADDRESS) token = if_empty(token, UNIT_TOKEN_ADDRESS) pkey = if_empty(pkey, UNIT_TRANSFER_PKEY) signer = LocalSigner(pkey) sender = if_empty(sender, UNIT_TRANSFER_SENDER) assert locked_amount >= amount secrethash = sha3(secret) lock = Lock( amount=amount, expiration=expiration, secrethash=secrethash, ) if locksroot == EMPTY_MERKLE_ROOT: locksroot = sha3(lock.as_bytes) transfer = LockedTransfer( chain_id=UNIT_CHAIN_ID, message_identifier=message_identifier, payment_identifier=payment_identifier, nonce=nonce, token_network_address=token_network_address, token=token, channel_identifier=channel_identifier, transferred_amount=transferred_amount, locked_amount=locked_amount, recipient=recipient, locksroot=locksroot, lock=lock, target=target, initiator=initiator, ) transfer.sign(signer) assert transfer.sender == sender return lockedtransfersigned_from_message(transfer)
def target_init(transfer: LockedTransfer) -> ActionInitTarget: from_transfer = lockedtransfersigned_from_message(transfer) from_route = RouteState(transfer.sender, from_transfer.balance_proof.channel_identifier) return ActionInitTarget(from_route, from_transfer)