code: def check_off_chain_transaction_roles(self, transactions):
          
          policy = None
          if "transactor.transaction_signer" in self._permissions:
              policy = self._permissions["transactor.transaction_signer"]
  
          elif "transactor" in self._permissions:
              policy = self._permissions["transactor"]
  
          for transaction in transactions:
              header = TransactionHeader()
              header.ParseFromString(transaction.header)
              family_role = "transactor.transaction_signer." + \
                  header.family_name
              family_policy = None
              if family_role in self._permissions:
                  family_policy = self._permissions[family_role]
  
              if family_policy is not None:
                  if not self._allowed(header.signer_public_key, family_policy):
                      LOGGER.debug("Transaction Signer: %s is not permitted"
                                   "by local configuration.",
                                   header.signer_public_key)
                      return False
  
              elif policy is not None:
                  if not self._allowed(header.signer_public_key, policy):
                      LOGGER.debug("Transaction Signer: %s is not permitted"
                                   "by local configuration.",
                                   header.signer_public_key)
                      return False
  
          return True
docs: Check the transaction signing key against the allowed off-chain
              transactor permissions. The roles being checked are the following,
              from first to last:
                  "transactor.transaction_signer.<TP_Name>"
                  "transactor.transaction_signer"
                  "transactor"
  
              The first role that is set will be the one used to enforce if the
              transaction signer is allowed.
  
              Args:
                  transactions (List of Transactions): The transactions that are
                      being verified.