code: def processPropagate(self, msg: Propagate, frm):
          
          logger.debug("{} received propagated request: {}".
                       format(self.name, msg))
  
          request = TxnUtilConfig.client_request_class(**msg.request)
  
          clientName = msg.senderClient
  
          if not self.isProcessingReq(request.key):
              ledger_id, seq_no = self.seqNoDB.get_by_payload_digest(request.payload_digest)
              if ledger_id is not None and seq_no is not None:
                  self._clean_req_from_verified(request)
                  logger.debug("{} ignoring propagated request {} "
                               "since it has been already ordered"
                               .format(self.name, msg))
                  return
  
              self.startedProcessingReq(request.key, clientName)
              # forced request should be processed before consensus
              self.handle_request_if_forced(request)
  
          else:
              if clientName is not None and \
                      not self.is_sender_known_for_req(request.key):
                  # Since some propagates might not include the client name
                  self.set_sender_for_req(request.key,
                                          clientName)
  
          self.requests.add_propagate(request, frm)
  
          self.propagate(request, clientName)
          self.tryForwarding(request)
docs: Process one propagateRequest sent to this node asynchronously
  
          - If this propagateRequest hasn't been seen by this node, then broadcast
          it to all nodes after verifying the the signature.
          - Add the client to blacklist if its signature is invalid
  
          :param msg: the propagateRequest
          :param frm: the name of the node which sent this `msg`