Method on_raiden_events

raiden/raiden_event_handler.py:167–221

(
        self, raiden: "RaidenService", chain_state: ChainState, events: List[Event]
    )

class RaidenEventHandler(EventHandler):
    def on_raiden_events(
        self, raiden: "RaidenService", chain_state: ChainState, events: List[Event]
    ) -> None:  # pragma: no unittest

        message_queues: Dict[
            QueueIdentifier, List[Tuple[Message, Optional[AddressMetadata]]]
        ] = defaultdict(list)

        event_handler_map: Dict[Any, List] = {
            SendLockExpired: [self.handle_send_lockexpired, [message_queues]],
            SendLockedTransfer: [self.handle_send_lockedtransfer, [message_queues]],
            SendSecretReveal: [self.handle_send_secretreveal, [message_queues]],
            SendUnlock: [self.handle_send_balanceproof, [message_queues]],
            SendSecretRequest: [self.handle_send_secretrequest, [chain_state, message_queues]],
            SendWithdrawRequest: [self.handle_send_withdrawrequest, [message_queues]],
            SendWithdrawConfirmation: [self.handle_send_withdraw, [message_queues]],
            SendWithdrawExpired: [self.handle_send_withdrawexpired, [message_queues]],
            SendProcessed: [self.handle_send_processed, [message_queues]],
            EventPaymentSentSuccess: [self.handle_paymentsentsuccess, []],
            EventPaymentSentFailed: [self.handle_paymentsentfailed, []],
            EventUnlockFailed: [self.handle_unlockfailed, []],
            EventInvalidSecretRequest: [self.handle_invalidsecretrequest, []],
            ContractSendSecretReveal: [self.handle_contract_send_secretreveal, []],
            ContractSendChannelClose: [self.handle_contract_send_channelclose, [chain_state]],
            ContractSendChannelUpdateTransfer: [self.handle_contract_send_channelupdate, []],
            ContractSendChannelBatchUnlock: [
                self.handle_contract_send_channelunlock,
                [chain_state],
            ],
            ContractSendChannelSettle: [self.handle_contract_send_channelsettle, []],
            ContractSendChannelWithdraw: [self.handle_contract_send_channelwithdraw, []],
            ContractSendChannelCoopSettle: [self.handle_contract_send_coopsettle, []],
            UpdateServicesAddresses: [self.handle_update_services_addresses, []],
            RequestMetadata: [self.handle_missing_metadata_events, [chain_state]],
        }

        for event in events:
            t_event = type(event)
            if t_event in event_handler_map:
                method, args = event_handler_map[t_event]
                method(raiden, event, *args)
            elif t_event in UNEVENTFUL_EVENTS:
                pass
            else:
                log.error(
                    "Unknown event",
                    event_type=str(t_event),
                    node=to_checksum_address(raiden.address),
                )

        all_messages: List[MessagesQueue] = [
            MessagesQueue(queue_identifier, messages)
            for queue_identifier, messages in message_queues.items()
        ]
        raiden.transport.send_async(all_messages)

    @staticmethod
    def handle_missing_metadata_events(