def handle_message_lockedtransfer( raiden: "RaidenService", message: LockedTransfer # pylint: disable=unused-argument ) -> List[StateChange]: secrethash = message.lock.secrethash # We must check if the secret was registered against the latest block, # even if the block is forked away and the transaction that registers # the secret is removed from the blockchain. The rationale here is that # someone else does know the secret, regardless of the chain state, so # the node must not use it to start a payment. # # For this particular case, it's preferable to use `latest` instead of # having a specific block_hash, because it's preferable to know if the secret # was ever known, rather than having a consistent view of the blockchain. registered = raiden.default_secret_registry.is_secret_registered( secrethash=secrethash, block_identifier=BLOCK_ID_LATEST ) if registered: log.warning( f"Ignoring received locked transfer with secrethash {to_hex(secrethash)} " f"since it is already registered in the secret registry" ) return [] assert message.sender, "Invalid message dispatched, it should be signed" from_transfer = lockedtransfersigned_from_message(message) from_hop = HopState( node_address=message.sender, # pylint: disable=E1101 channel_identifier=from_transfer.balance_proof.channel_identifier, ) if message.target == TargetAddress(raiden.address): raiden.immediate_health_check_for(Address(message.initiator)) return [ ActionInitTarget( from_hop=from_hop, transfer=from_transfer, balance_proof=from_transfer.balance_proof, sender=from_transfer.balance_proof.sender, ) ] else: route_states = routing.resolve_routes( routes=message.metadata.routes, token_network_address=from_transfer.balance_proof.token_network_address, chain_state=views.state_from_raiden(raiden), ) return [ ActionInitMediator( from_hop=from_hop, route_states=route_states, from_transfer=from_transfer, balance_proof=from_transfer.balance_proof, sender=from_transfer.balance_proof.sender, ) ]
def locked_transfer_to_action_init_target( locked_transfer: LockedTransfer) -> ActionInitTarget: from_transfer = lockedtransfersigned_from_message(locked_transfer) channel_id = from_transfer.balance_proof.channel_identifier # pylint: disable=no-member from_hop = HopState(node_address=Address(locked_transfer.initiator), channel_identifier=channel_id) init_target_statechange = ActionInitTarget( from_hop=from_hop, transfer=from_transfer, balance_proof=from_transfer.balance_proof, sender=from_transfer.balance_proof.sender, # pylint: disable=no-member ) return init_target_statechange
def handle_message_refundtransfer( raiden: "RaidenService", message: RefundTransfer ) -> List[StateChange]: chain_state = views.state_from_raiden(raiden) from_transfer = lockedtransfersigned_from_message(message=message) role = views.get_transfer_role( chain_state=chain_state, secrethash=from_transfer.lock.secrethash ) state_changes: List[StateChange] = [] if role == "initiator": old_secret = views.get_transfer_secret(chain_state, from_transfer.lock.secrethash) is_secret_known = old_secret is not None and old_secret != ABSENT_SECRET state_changes.append( ReceiveTransferCancelRoute( transfer=from_transfer, balance_proof=from_transfer.balance_proof, sender=from_transfer.balance_proof.sender, # pylint: disable=no-member ) ) # Currently, the only case where we can be initiators and not # know the secret is if the transfer is part of an atomic swap. In # the case of an atomic swap, we will not try to re-route the # transfer. In all other cases we can try to find another route # (and generate a new secret) if is_secret_known: state_changes.append( ActionTransferReroute( transfer=from_transfer, balance_proof=from_transfer.balance_proof, # pylint: disable=no-member sender=from_transfer.balance_proof.sender, # pylint: disable=no-member secret=random_secret(), ) ) else: state_changes.append( ReceiveTransferRefund( transfer=from_transfer, balance_proof=from_transfer.balance_proof, sender=from_transfer.balance_proof.sender, # pylint: disable=no-member ) ) return state_changes
def signed_transfer_from_description( private_key: PrivateKey, description: TransferDescriptionWithSecretState, channel: NettingChannelState, message_id: MessageID, block_number: BlockNumber, route_state: RouteState, route_states: List[RouteState], ) -> LockedTransferSignedState: send_locked_transfer = send_lockedtransfer( transfer_description=description, channel_state=channel, message_identifier=message_id, block_number=block_number, route_state=route_state, route_states=route_states, ) message = message_from_sendevent(send_locked_transfer) assert isinstance(message, LockedTransfer), MYPY_ANNOTATION message.sign(LocalSigner(private_key)) return lockedtransfersigned_from_message(message)