fmt: apply clang-format

knst · knst · commit 46a28e680194 · 2025-09-18T19:27:20.000+07:00
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
@@ -87,8 +87,7 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
     chainlock::ChainLockSig GetBestChainLock() const
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    void UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time) override
-        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time) override EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const chainlock::ChainLockSig& clsig,
                                                               const uint256& hash) override
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
@@ -80,8 +80,7 @@ class ChainLockSigner final : public llmq::CRecoveredSigsListener
     [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override
         EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
 
-    [[nodiscard]] std::vector<std::shared_ptr<Uint256HashSet>> Cleanup()
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+    [[nodiscard]] std::vector<std::shared_ptr<Uint256HashSet>> Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
 
 private:
     [[nodiscard]] BlockTxs::mapped_type GetBlockTxs(const uint256& blockHash)
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
@@ -58,8 +58,7 @@ auto CachedGetQcHashesQcIndexedHashes(const CBlockIndex* pindexPrev, const llmq:
 
     static Mutex cs_cache;
     static std::map<Consensus::LLMQType, std::vector<const CBlockIndex*>> quorums_cached GUARDED_BY(cs_cache);
-    static std::map<Consensus::LLMQType, Uint256LruHashMap<std::pair<uint256, int>>> qc_hashes_cached
-        GUARDED_BY(cs_cache);
+    static std::map<Consensus::LLMQType, Uint256LruHashMap<std::pair<uint256, int>>> qc_hashes_cached GUARDED_BY(cs_cache);
     static QcHashMap qcHashes_cached GUARDED_BY(cs_cache);
     static QcIndexedHashMap qcIndexedHashes_cached GUARDED_BY(cs_cache);
 
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
@@ -68,8 +68,8 @@ static std::optional<CreditPoolDataPerBlock> GetCreditDataFromBlock(const gsl::n
     CreditPoolDataPerBlock blockData;
 
     static Mutex cache_mutex;
-    static Uint256LruHashMap<CreditPoolDataPerBlock> block_data_cache GUARDED_BY(
-        cache_mutex){static_cast<size_t>(Params().CreditPoolPeriodBlocks()) * 2};
+    static Uint256LruHashMap<CreditPoolDataPerBlock> block_data_cache GUARDED_BY(cache_mutex){
+        static_cast<size_t>(Params().CreditPoolPeriodBlocks()) * 2};
     if (LOCK(cache_mutex); block_data_cache.get(block_index->GetBlockHash(), blockData)) {
         return blockData;
     }
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
@@ -111,7 +111,7 @@ class CCreditPoolManager
 private:
     static constexpr size_t CreditPoolCacheSize = 1000;
     Mutex cache_mutex;
-    Uint256LruHashMap<CCreditPool> creditPoolCache GUARDED_BY(cache_mutex) {CreditPoolCacheSize};
+    Uint256LruHashMap<CCreditPool> creditPoolCache GUARDED_BY(cache_mutex){CreditPoolCacheSize};
 
     CEvoDB& evoDb;
 
diff --git a/src/evo/mnhftx.h b/src/evo/mnhftx.h
@@ -97,7 +97,7 @@ class CMNHFManager : public AbstractEHFManager
     static constexpr size_t MNHFCacheSize = 1000;
     Mutex cs_cache;
     // versionBit <-> height
-    Uint256LruHashMap<Signals> mnhfCache GUARDED_BY(cs_cache) {MNHFCacheSize};
+    Uint256LruHashMap<Signals> mnhfCache GUARDED_BY(cs_cache){MNHFCacheSize};
 
 public:
     explicit CMNHFManager(CEvoDB& evoDb);
diff --git a/src/instantsend/instantsend.h b/src/instantsend/instantsend.h
@@ -110,10 +110,9 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
     instantsend::PendingState ProcessPendingInstantSendLocks()
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
 
-    Uint256HashSet ProcessPendingInstantSendLocks(
-        const Consensus::LLMQParams& llmq_params, int signOffset, bool ban,
-        const Uint256HashMap<std::pair<NodeId, instantsend::InstantSendLockPtr>>& pend,
-        std::vector<std::pair<NodeId, MessageProcessingResult>>& peer_activity)
+    Uint256HashSet ProcessPendingInstantSendLocks(const Consensus::LLMQParams& llmq_params, int signOffset, bool ban,
+                                                  const Uint256HashMap<std::pair<NodeId, instantsend::InstantSendLockPtr>>& pend,
+                                                  std::vector<std::pair<NodeId, MessageProcessingResult>>& peer_activity)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
     MessageProcessingResult ProcessInstantSendLock(NodeId from, const uint256& hash,
                                                    const instantsend::InstantSendLockPtr& islock)
diff --git a/src/instantsend/signing.h b/src/instantsend/signing.h
@@ -78,8 +78,7 @@ class InstantSendSigner final : public llmq::CRecoveredSigsListener
     void Start();
     void Stop();
 
-    void ClearInputsFromQueue(const Uint256HashSet& ids)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_input_requests);
+    void ClearInputsFromQueue(const Uint256HashSet& ids) EXCLUSIVE_LOCKS_REQUIRED(!cs_input_requests);
 
     void ClearLockFromQueue(const InstantSendLockPtr& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating);
diff --git a/src/llmq/quorums.h b/src/llmq/quorums.h
@@ -250,7 +250,8 @@ class CQuorumManager
     mutable Mutex cs_map_quorums;
     mutable std::map<Consensus::LLMQType, Uint256LruHashMap<CQuorumPtr>> mapQuorumsCache GUARDED_BY(cs_map_quorums);
     mutable Mutex cs_scan_quorums;
-    mutable std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CQuorumCPtr>>> scanQuorumsCache GUARDED_BY(cs_scan_quorums);
+    mutable std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CQuorumCPtr>>> scanQuorumsCache
+        GUARDED_BY(cs_scan_quorums);
     mutable Mutex cs_cleanup;
     mutable std::map<Consensus::LLMQType, Uint256LruHashMap<uint256>> cleanupQuorumsCache GUARDED_BY(cs_cleanup);
 
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
@@ -1049,9 +1049,8 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No
     }
 }
 
-void CSigSharesManager::CollectSigSharesToAnnounce(
-    const CConnman& connman,
-    std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)
+void CSigSharesManager::CollectSigSharesToAnnounce(const CConnman& connman,
+                                                   std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)
 {
     AssertLockHeld(cs);
 
diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h
@@ -477,12 +477,13 @@ class CSigSharesManager : public CRecoveredSigsListener
     void BanNode(NodeId nodeId, PeerManager& peerman);
 
     bool SendMessages(CConnman& connman);
-    void CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    void CollectSigSharesToSend(std::unordered_map<NodeId, Uint256HashMap<CBatchedSigShares>>& sigSharesToSend) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest)
+        EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void CollectSigSharesToSend(std::unordered_map<NodeId, Uint256HashMap<CBatchedSigShares>>& sigSharesToSend)
+        EXCLUSIVE_LOCKS_REQUIRED(cs);
     void CollectSigSharesToSendConcentrated(std::unordered_map<NodeId, std::vector<CSigShare>>& sigSharesToSend, const std::vector<CNode*>& vNodes) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    void CollectSigSharesToAnnounce(
-        const CConnman& connman,
-        std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)
+    void CollectSigSharesToAnnounce(const CConnman& connman,
+                                    std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     void SignPendingSigShares(const CConnman& connman, PeerManager& peerman);
     void WorkThreadMain(CConnman& connman, PeerManager& peerman);
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
@@ -204,7 +204,8 @@ std::vector<CDeterministicMNCPtr> GetAllQuorumMembers(Consensus::LLMQType llmqTy
                                                       bool reset_cache)
 {
     static RecursiveMutex cs_members;
-    static std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CDeterministicMNCPtr>>> mapQuorumMembers GUARDED_BY(cs_members);
+    static std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CDeterministicMNCPtr>>> mapQuorumMembers GUARDED_BY(
+        cs_members);
     static RecursiveMutex cs_indexed_members;
     static std::map<Consensus::LLMQType, unordered_lru_cache<std::pair<uint256, int>, std::vector<CDeterministicMNCPtr>, StaticSaltedHasher>> mapIndexedQuorumMembers GUARDED_BY(cs_indexed_members);
     if (!IsQuorumTypeEnabled(llmqType, pQuorumBaseBlockIndex->pprev)) {
@@ -732,10 +733,10 @@ uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256
     return proTxHash2;
 }
 
-Uint256HashSet GetQuorumConnections(
-    const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
-    const CSporkManager& sporkman, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember,
-    bool onlyOutbound)
+Uint256HashSet GetQuorumConnections(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman,
+                                    CQuorumSnapshotManager& qsnapman, const CSporkManager& sporkman,
+                                    gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember,
+                                    bool onlyOutbound)
 {
     if (IsAllMembersConnectedEnabled(llmqParams.type, sporkman)) {
         auto mns = GetAllQuorumMembers(llmqParams.type, dmnman, qsnapman, pQuorumBaseBlockIndex);
@@ -758,9 +759,10 @@ Uint256HashSet GetQuorumConnections(
     return GetQuorumRelayMembers(llmqParams, dmnman, qsnapman, pQuorumBaseBlockIndex, forMember, onlyOutbound);
 }
 
-Uint256HashSet GetQuorumRelayMembers(
-    const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
-    gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
+Uint256HashSet GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman,
+                                     CQuorumSnapshotManager& qsnapman,
+                                     gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember,
+                                     bool onlyOutbound)
 {
     auto mns = GetAllQuorumMembers(llmqParams.type, dmnman, qsnapman, pQuorumBaseBlockIndex);
     Uint256HashSet result;
@@ -968,14 +970,21 @@ void InitQuorumsCache(CacheType& cache, bool limit_by_connections)
                       std::forward_as_tuple(limit_by_connections ? llmq.keepOldConnections : llmq.keepOldKeys));
     }
 }
-template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<bool>>>(std::map<Consensus::LLMQType, Uint256LruHashMap<bool>>& cache, bool limit_by_connections);
-template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CQuorumCPtr>>>>(std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CQuorumCPtr>>>& cache, bool limit_by_connections);
-template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>, std::less<Consensus::LLMQType>, std::allocator<std::pair<Consensus::LLMQType const, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>>>>>(std::map<Consensus::LLMQType, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>, std::less<Consensus::LLMQType>, std::allocator<std::pair<Consensus::LLMQType const, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>>>>&cache, bool limit_by_connections);
-template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<int>>>(std::map<Consensus::LLMQType, Uint256LruHashMap<int>>& cache, bool limit_by_connections);
-template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<uint256>>>(std::map<Consensus::LLMQType, Uint256LruHashMap<uint256>>& cache, bool limit_by_connections);
-template void
-InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<std::pair<uint256, int>>>>(
-    std::map<Consensus::LLMQType, Uint256LruHashMap<std::pair<uint256, int>>>& cache,
+template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<bool>>>(
+    std::map<Consensus::LLMQType, Uint256LruHashMap<bool>>& cache, bool limit_by_connections);
+template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CQuorumCPtr>>>>(
+    std::map<Consensus::LLMQType, Uint256LruHashMap<std::vector<CQuorumCPtr>>>& cache, bool limit_by_connections);
+template void InitQuorumsCache<
+    std::map<Consensus::LLMQType, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>, std::less<Consensus::LLMQType>,
+             std::allocator<std::pair<Consensus::LLMQType const, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>>>>>(
+    std::map<Consensus::LLMQType, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>, std::less<Consensus::LLMQType>,
+             std::allocator<std::pair<Consensus::LLMQType const, Uint256LruHashMap<std::shared_ptr<llmq::CQuorum>>>>>& cache,
     bool limit_by_connections);
+template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<int>>>(
+    std::map<Consensus::LLMQType, Uint256LruHashMap<int>>& cache, bool limit_by_connections);
+template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<uint256>>>(
+    std::map<Consensus::LLMQType, Uint256LruHashMap<uint256>>& cache, bool limit_by_connections);
+template void InitQuorumsCache<std::map<Consensus::LLMQType, Uint256LruHashMap<std::pair<uint256, int>>>>(
+    std::map<Consensus::LLMQType, Uint256LruHashMap<std::pair<uint256, int>>>& cache, bool limit_by_connections);
 } // namespace utils
 } // namespace llmq
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
@@ -38,13 +38,14 @@ std::vector<CDeterministicMNCPtr> GetAllQuorumMembers(Consensus::LLMQType llmqTy
                                                       bool reset_cache = false);
 
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2);
-Uint256HashSet GetQuorumConnections(
-    const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
-    const CSporkManager& sporkman, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember,
-    bool onlyOutbound);
-Uint256HashSet GetQuorumRelayMembers(
-    const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
-    gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
+Uint256HashSet GetQuorumConnections(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman,
+                                    CQuorumSnapshotManager& qsnapman, const CSporkManager& sporkman,
+                                    gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember,
+                                    bool onlyOutbound);
+Uint256HashSet GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman,
+                                     CQuorumSnapshotManager& qsnapman,
+                                     gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember,
+                                     bool onlyOutbound);
 std::set<size_t> CalcDeterministicWatchConnections(Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, size_t memberCount, size_t connectionCount);
 
 bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman& connman,
diff --git a/src/qt/sedsoVLyW b/src/qt/sedsoVLyW
diff --git a/src/saltedhasher.h b/src/saltedhasher.h
@@ -83,7 +83,7 @@ using Uint256HashMap = std::unordered_map<uint256, T, StaticSaltedHasher>;
 using Uint256HashSet = std::unordered_set<uint256, StaticSaltedHasher>;
 
 
-template<typename Key, typename Value, typename Hasher, size_t MaxSize, size_t TruncateThreshold>
+template <typename Key, typename Value, typename Hasher, size_t MaxSize, size_t TruncateThreshold>
 class unordered_lru_cache;
 template <typename T, size_t MaxSize = 0ul, size_t TruncateThreshold = 0ul>
 using Uint256LruHashMap = unordered_lru_cache<uint256, T, StaticSaltedHasher, MaxSize, TruncateThreshold>;

Original file line number	Diff line number	Diff line change
`@@ -1049,9 +1049,8 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No`
`1049`	`1049`	`}`
`1050`	`1050`	`}`
`1051`	`1051`
`1052`		`-void CSigSharesManager::CollectSigSharesToAnnounce(`
`1053`		`- const CConnman& connman,`
`1054`		`- std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)`
	`1052`	`+void CSigSharesManager::CollectSigSharesToAnnounce(const CConnman& connman,`
	`1053`	`+ std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)`
`1055`	`1054`	`{`
`1056`	`1055`	`AssertLockHeld(cs);`
`1057`	`1056`