refactor: s/cs_inputReqests/cs_input_requests/g

Author: kwvg

src/instantsend/signing.cpp

@@ -60,7 +60,7 @@ void InstantSendSigner::Stop()
 
 void InstantSendSigner::ClearInputsFromQueue(const std::unordered_set<uint256, StaticSaltedHasher>& ids)
 {
-    LOCK(cs_inputReqests);
+    LOCK(cs_input_requests);
     for (const auto& id : ids) {
         inputRequestIds.erase(id);
     }
@@ -84,7 +84,7 @@ MessageProcessingResult InstantSendSigner::HandleNewRecoveredSig(const llmq::CRe
     }
 
     uint256 txid;
-    if (LOCK(cs_inputReqests); inputRequestIds.count(recoveredSig.getId())) {
+    if (LOCK(cs_input_requests); inputRequestIds.count(recoveredSig.getId())) {
         txid = recoveredSig.getMsgHash();
     }
     if (!txid.IsNull()) {
@@ -331,7 +331,7 @@ bool InstantSendSigner::TrySignInputLocks(const CTransaction& tx, bool fRetroact
     for (const auto i : irange::range(tx.vin.size())) {
         const auto& in = tx.vin[i];
         auto& id = ids[i];
-        WITH_LOCK(cs_inputReqests, inputRequestIds.emplace(id));
+        WITH_LOCK(cs_input_requests, inputRequestIds.emplace(id));
         LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: trying to vote on input %s with id %s. fRetroactive=%d\n",
                  __func__, tx.GetHash().ToString(), in.prevout.ToStringShort(), id.ToString(), fRetroactive);
         if (m_sigman.AsyncSignIfMember(llmqType, m_shareman, id, tx.GetHash(), {}, fRetroactive)) {

src/instantsend/signing.h

@@ -39,14 +39,14 @@ class InstantSendSigner : public llmq::CRecoveredSigsListener
     const CMasternodeSync& m_mn_sync;
 
 private:
-    mutable Mutex cs_inputReqests;
+    mutable Mutex cs_input_requests;
     mutable Mutex cs_creating;
 
     /**
      * Request ids of inputs that we signed. Used to determine if a recovered signature belongs to an
      * in-progress input lock.
      */
-    std::unordered_set<uint256, StaticSaltedHasher> inputRequestIds GUARDED_BY(cs_inputReqests);
+    std::unordered_set<uint256, StaticSaltedHasher> inputRequestIds GUARDED_BY(cs_input_requests);
 
     /**
      * These are the islocks that are currently in the middle of being created. Entries are created when we observed
@@ -68,18 +68,18 @@ class InstantSendSigner : public llmq::CRecoveredSigsListener
     void Stop();
 
     void ClearInputsFromQueue(const std::unordered_set<uint256, StaticSaltedHasher>& ids)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_inputReqests);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_input_requests);
 
     void ClearLockFromQueue(const InstantSendLockPtr& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating);
 
     [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_input_requests);
 
     void ProcessPendingRetryLockTxs(const std::vector<CTransactionRef>& retryTxs)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_input_requests);
     void ProcessTx(const CTransaction& tx, bool fRetroactive, const Consensus::Params& params)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_input_requests);
 
 private:
     [[nodiscard]] bool CheckCanLock(const CTransaction& tx, bool printDebug, const Consensus::Params& params) const;
@@ -95,7 +95,7 @@ class InstantSendSigner : public llmq::CRecoveredSigsListener
 
     [[nodiscard]] bool TrySignInputLocks(const CTransaction& tx, bool allowResigning, Consensus::LLMQType llmqType,
                                          const Consensus::Params& params)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_inputReqests);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_input_requests);
     void TrySignInstantSendLock(const CTransaction& tx)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating);
 };