code: def _initialize_transactions_queues(self, chain_state: ChainState):
          
          assert self.alarm.is_primed(), f'AlarmTask not primed. node:{self!r}'
  
          pending_transactions = views.get_pending_transactions(chain_state)
  
          log.debug(
              'Processing pending transactions',
              num_pending_transactions=len(pending_transactions),
              node=pex(self.address),
          )
  
          for transaction in pending_transactions:
              try:
                  self.raiden_event_handler.on_raiden_event(self, transaction)
              except RaidenRecoverableError as e:
                  log.error(str(e))
              except InvalidDBData:
                  raise
              except RaidenUnrecoverableError as e:
                  log_unrecoverable = (
                      self.config['environment_type'] == Environment.PRODUCTION and
                      not self.config['unrecoverable_error_should_crash']
                  )
                  if log_unrecoverable:
                      log.error(str(e))
                  else:
                      raise
docs: Initialize the pending transaction queue from the previous run.
  
          Note:
              This will only send the transactions which don't have their
              side-effects applied. Transactions which another node may have sent
              already will be detected by the alarm task's first run and cleared
              from the queue (e.g. A monitoring service update transfer).