refactor: use Uint256HashMap all over codebase

knst · knst · commit c8c6d29bf15e · 2025-09-18T19:27:19.000+07:00
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
@@ -59,7 +59,7 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
     const CBlockIndex* bestChainLockBlockIndex GUARDED_BY(cs){nullptr};
     const CBlockIndex* lastNotifyChainLockBlockIndex GUARDED_BY(cs){nullptr};
 
-    std::unordered_map<uint256, std::chrono::seconds, StaticSaltedHasher> txFirstSeenTime GUARDED_BY(cs);
+    Uint256HashMap<std::chrono::seconds> txFirstSeenTime GUARDED_BY(cs);
 
     std::map<uint256, std::chrono::seconds> seenChainLocks GUARDED_BY(cs);
 
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
@@ -627,8 +627,8 @@ class CDeterministicMNManager
 
     CEvoDB& m_evoDb;
 
-    std::unordered_map<uint256, CDeterministicMNList, StaticSaltedHasher> mnListsCache GUARDED_BY(cs);
-    std::unordered_map<uint256, CDeterministicMNListDiff, StaticSaltedHasher> mnListDiffsCache GUARDED_BY(cs);
+    Uint256HashMap<CDeterministicMNList> mnListsCache GUARDED_BY(cs);
+    Uint256HashMap<CDeterministicMNListDiff> mnListDiffsCache GUARDED_BY(cs);
     const CBlockIndex* tipIndex GUARDED_BY(cs) {nullptr};
     const CBlockIndex* m_initial_snapshot_index GUARDED_BY(cs) {nullptr};
 
diff --git a/src/instantsend/db.cpp b/src/instantsend/db.cpp
@@ -116,7 +116,7 @@ void CInstantSendDb::WriteInstantSendLockArchived(CDBBatch& batch, const uint256
     batch.Write(std::make_tuple(DB_ARCHIVED_BY_HASH, hash), true);
 }
 
-std::unordered_map<uint256, InstantSendLockPtr, StaticSaltedHasher> CInstantSendDb::RemoveConfirmedInstantSendLocks(int nUntilHeight)
+Uint256HashMap<InstantSendLockPtr> CInstantSendDb::RemoveConfirmedInstantSendLocks(int nUntilHeight)
 {
     LOCK(cs_db);
     if (nUntilHeight <= best_confirmed_height) {
@@ -133,7 +133,7 @@ std::unordered_map<uint256, InstantSendLockPtr, StaticSaltedHasher> CInstantSend
     it->Seek(firstKey);
 
     CDBBatch batch(*db);
-    std::unordered_map<uint256, InstantSendLockPtr, StaticSaltedHasher> ret;
+    Uint256HashMap<InstantSendLockPtr> ret;
     while (it->Valid()) {
         decltype(firstKey) curKey;
         if (!it->GetKey(curKey) || std::get<0>(curKey) != DB_MINED_BY_HEIGHT_AND_HASH) {
diff --git a/src/instantsend/db.h b/src/instantsend/db.h
@@ -101,7 +101,7 @@ class CInstantSendDb
      * @param nUntilHeight Removes all IS Locks confirmed up until nUntilHeight
      * @return returns an unordered_map of the hash of the IS Locks and a pointer object to the IS Locks for all IS Locks which were removed
      */
-    std::unordered_map<uint256, InstantSendLockPtr, StaticSaltedHasher> RemoveConfirmedInstantSendLocks(int nUntilHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_db);
+    Uint256HashMap<InstantSendLockPtr> RemoveConfirmedInstantSendLocks(int nUntilHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_db);
     /**
      * Removes IS Locks from the archive if the tx was confirmed 100 blocks before nUntilHeight
      * @param nUntilHeight the height from which to base the remove of archive IS Locks
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
@@ -236,7 +236,7 @@ Uint256HashSet CInstantSendManager::ProcessPendingInstantSendLocks(
     std::vector<std::pair<NodeId, MessageProcessingResult>>& peer_activity)
 {
     CBLSBatchVerifier<NodeId, uint256> batchVerifier(false, true, 8);
-    std::unordered_map<uint256, CRecoveredSig, StaticSaltedHasher> recSigs;
+    Uint256HashMap<CRecoveredSig> recSigs;
 
     size_t verifyCount = 0;
     size_t alreadyVerified = 0;
@@ -689,7 +689,7 @@ void CInstantSendManager::HandleFullyConfirmedBlock(const CBlockIndex* pindex)
 
 void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock)
 {
-    std::unordered_map<uint256, CTransactionRef, StaticSaltedHasher> toDelete;
+    Uint256HashMap<CTransactionRef> toDelete;
 
     {
         LOCK(mempool.cs);
@@ -720,7 +720,7 @@ void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, con
 void CInstantSendManager::ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock)
 {
     // Lets first collect all non-locked TXs which conflict with the given ISLOCK
-    std::unordered_map<const CBlockIndex*, std::unordered_map<uint256, CTransactionRef, StaticSaltedHasher>> conflicts;
+    std::unordered_map<const CBlockIndex*, Uint256HashMap<CTransactionRef>> conflicts;
     {
         LOCK(cs_nonLocked);
         for (const auto& in : islock.inputs) {
diff --git a/src/instantsend/instantsend.h b/src/instantsend/instantsend.h
@@ -79,7 +79,7 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
     };
 
     mutable Mutex cs_nonLocked;
-    std::unordered_map<uint256, NonLockedTxInfo, StaticSaltedHasher> nonLockedTxs GUARDED_BY(cs_nonLocked);
+    Uint256HashMap<NonLockedTxInfo> nonLockedTxs GUARDED_BY(cs_nonLocked);
     std::unordered_map<COutPoint, uint256, SaltedOutpointHasher> nonLockedTxsByOutpoints GUARDED_BY(cs_nonLocked);
 
     mutable Mutex cs_pendingRetry;
diff --git a/src/instantsend/signing.h b/src/instantsend/signing.h
@@ -64,7 +64,7 @@ class InstantSendSigner final : public llmq::CRecoveredSigsListener
      * recovered signatures for all inputs of a TX. At the same time, we initiate signing of our sigshare for the
      * islock. When the recovered sig for the islock later arrives, we can finish the islock and propagate it.
      */
-    std::unordered_map<uint256, InstantSendLock, StaticSaltedHasher> creatingInstantSendLocks GUARDED_BY(cs_creating);
+    Uint256HashMap<InstantSendLock> creatingInstantSendLocks GUARDED_BY(cs_creating);
     // maps from txid to the in-progress islock
     std::unordered_map<uint256, InstantSendLock*, StaticSaltedHasher> txToCreatingInstantSendLocks GUARDED_BY(cs_creating);
 
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
@@ -469,7 +469,7 @@ void CDKGSession::VerifyConnectionAndMinProtoVersions(CConnman& connman) const
 
     CDKGLogger logger(*this, __func__, __LINE__);
 
-    std::unordered_map<uint256, int, StaticSaltedHasher> protoMap;
+    Uint256HashMap<int> protoMap;
     connman.ForEachNode([&](const CNode* pnode) {
         auto verifiedProRegTxHash = pnode->GetVerifiedProRegTxHash();
         if (verifiedProRegTxHash.IsNull()) {
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
@@ -857,7 +857,7 @@ CDeterministicMNCPtr CSigSharesManager::SelectMemberForRecovery(const CQuorumCPt
     return v[attempt % v.size()].second;
 }
 
-void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>>& sigSharesToRequest)
+void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest)
 {
     AssertLockHeld(cs);
 
@@ -954,7 +954,7 @@ void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, std
     }
 }
 
-void CSigSharesManager::CollectSigSharesToSend(std::unordered_map<NodeId, std::unordered_map<uint256, CBatchedSigShares, StaticSaltedHasher>>& sigSharesToSend)
+void CSigSharesManager::CollectSigSharesToSend(std::unordered_map<NodeId, Uint256HashMap<CBatchedSigShares>>& sigSharesToSend)
 {
     AssertLockHeld(cs);
 
@@ -1051,7 +1051,7 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No
 
 void CSigSharesManager::CollectSigSharesToAnnounce(
     const CConnman& connman,
-    std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>>& sigSharesToAnnounce)
+    std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)
 {
     AssertLockHeld(cs);
 
@@ -1110,10 +1110,10 @@ void CSigSharesManager::CollectSigSharesToAnnounce(
 
 bool CSigSharesManager::SendMessages(CConnman& connman)
 {
-    std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>> sigSharesToRequest;
-    std::unordered_map<NodeId, std::unordered_map<uint256, CBatchedSigShares, StaticSaltedHasher>> sigShareBatchesToSend;
+    std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>> sigSharesToRequest;
+    std::unordered_map<NodeId, Uint256HashMap<CBatchedSigShares>> sigShareBatchesToSend;
     std::unordered_map<NodeId, std::vector<CSigShare>> sigSharesToSend;
-    std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>> sigSharesToAnnounce;
+    std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>> sigSharesToAnnounce;
     std::unordered_map<NodeId, std::vector<CSigSesAnn>> sigSessionAnnouncements;
 
     auto addSigSesAnnIfNeeded = [&](NodeId nodeId, const uint256& signHash) EXCLUSIVE_LOCKS_REQUIRED(cs) {
diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h
@@ -330,7 +330,7 @@ class CSigSharesNodeState
         CSigSharesInv knows;
     };
     // TODO limit number of sessions per node
-    std::unordered_map<uint256, Session, StaticSaltedHasher> sessions;
+    Uint256HashMap<Session> sessions;
 
     std::unordered_map<uint32_t, Session*> sessionByRecvId;
 
@@ -381,7 +381,7 @@ class CSigSharesManager : public CRecoveredSigsListener
     CThreadInterrupt workInterrupt;
 
     SigShareMap<CSigShare> sigShares GUARDED_BY(cs);
-    std::unordered_map<uint256, CSignedSession, StaticSaltedHasher> signedSessions GUARDED_BY(cs);
+    Uint256HashMap<CSignedSession> signedSessions GUARDED_BY(cs);
 
     // stores time of last receivedSigShare. Used to detect timeouts
     std::unordered_map<uint256, int64_t, StaticSaltedHasher> timeSeenForSessions GUARDED_BY(cs);
@@ -477,12 +477,12 @@ class CSigSharesManager : public CRecoveredSigsListener
     void BanNode(NodeId nodeId, PeerManager& peerman);
 
     bool SendMessages(CConnman& connman);
-    void CollectSigSharesToRequest(std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>>& sigSharesToRequest) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    void CollectSigSharesToSend(std::unordered_map<NodeId, std::unordered_map<uint256, CBatchedSigShares, StaticSaltedHasher>>& 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, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>>& sigSharesToAnnounce)
+        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/spork.h b/src/spork.h
@@ -165,7 +165,7 @@ class SporkStore
 
     mutable Mutex cs;
 
-    std::unordered_map<uint256, CSporkMessage, StaticSaltedHasher> mapSporksByHash GUARDED_BY(cs);
+    Uint256HashMap<CSporkMessage> mapSporksByHash GUARDED_BY(cs);
     std::unordered_map<SporkId, std::map<CKeyID, CSporkMessage> > mapSporksActive GUARDED_BY(cs);
 
 public:

Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ Uint256HashSet CInstantSendManager::ProcessPendingInstantSendLocks(`
`236`	`236`	`std::vector<std::pair<NodeId, MessageProcessingResult>>& peer_activity)`
`237`	`237`	`{`
`238`	`238`	`CBLSBatchVerifier<NodeId, uint256> batchVerifier(false, true, 8);`
`239`		`- std::unordered_map<uint256, CRecoveredSig, StaticSaltedHasher> recSigs;`
	`239`	`+ Uint256HashMap<CRecoveredSig> recSigs;`
`240`	`240`
`241`	`241`	`size_t verifyCount = 0;`
`242`	`242`	`size_t alreadyVerified = 0;`
`@@ -689,7 +689,7 @@ void CInstantSendManager::HandleFullyConfirmedBlock(const CBlockIndex* pindex)`
`689`	`689`
`690`	`690`	`void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock)`
`691`	`691`	`{`
`692`		`- std::unordered_map<uint256, CTransactionRef, StaticSaltedHasher> toDelete;`
	`692`	`+ Uint256HashMap<CTransactionRef> toDelete;`
`693`	`693`
`694`	`694`	`{`
`695`	`695`	`LOCK(mempool.cs);`
`@@ -720,7 +720,7 @@ void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, con`
`720`	`720`	`void CInstantSendManager::ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock)`
`721`	`721`	`{`
`722`	`722`	`// Lets first collect all non-locked TXs which conflict with the given ISLOCK`
`723`		`- std::unordered_map<const CBlockIndex*, std::unordered_map<uint256, CTransactionRef, StaticSaltedHasher>> conflicts;`
	`723`	`+ std::unordered_map<const CBlockIndex*, Uint256HashMap<CTransactionRef>> conflicts;`
`724`	`724`	`{`
`725`	`725`	`LOCK(cs_nonLocked);`
`726`	`726`	`for (const auto& in : islock.inputs) {`
Original file line number	Diff line number	Diff line change
`@@ -857,7 +857,7 @@ CDeterministicMNCPtr CSigSharesManager::SelectMemberForRecovery(const CQuorumCPt`
`857`	`857`	`return v[attempt % v.size()].second;`
`858`	`858`	`}`
`859`	`859`
`860`		`-void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>>& sigSharesToRequest)`
	`860`	`+void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest)`
`861`	`861`	`{`
`862`	`862`	`AssertLockHeld(cs);`
`863`	`863`
`@@ -954,7 +954,7 @@ void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, std`
`954`	`954`	`}`
`955`	`955`	`}`
`956`	`956`
`957`		`-void CSigSharesManager::CollectSigSharesToSend(std::unordered_map<NodeId, std::unordered_map<uint256, CBatchedSigShares, StaticSaltedHasher>>& sigSharesToSend)`
	`957`	`+void CSigSharesManager::CollectSigSharesToSend(std::unordered_map<NodeId, Uint256HashMap<CBatchedSigShares>>& sigSharesToSend)`
`958`	`958`	`{`
`959`	`959`	`AssertLockHeld(cs);`
`960`	`960`
`@@ -1051,7 +1051,7 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No`
`1051`	`1051`
`1052`	`1052`	`void CSigSharesManager::CollectSigSharesToAnnounce(`
`1053`	`1053`	`const CConnman& connman,`
`1054`		`- std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>>& sigSharesToAnnounce)`
	`1054`	`+ std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToAnnounce)`
`1055`	`1055`	`{`
`1056`	`1056`	`AssertLockHeld(cs);`
`1057`	`1057`
`@@ -1110,10 +1110,10 @@ void CSigSharesManager::CollectSigSharesToAnnounce(`
`1110`	`1110`
`1111`	`1111`	`bool CSigSharesManager::SendMessages(CConnman& connman)`
`1112`	`1112`	`{`
`1113`		`- std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>> sigSharesToRequest;`
`1114`		`- std::unordered_map<NodeId, std::unordered_map<uint256, CBatchedSigShares, StaticSaltedHasher>> sigShareBatchesToSend;`
	`1113`	`+ std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>> sigSharesToRequest;`
	`1114`	`+ std::unordered_map<NodeId, Uint256HashMap<CBatchedSigShares>> sigShareBatchesToSend;`
`1115`	`1115`	`std::unordered_map<NodeId, std::vector<CSigShare>> sigSharesToSend;`
`1116`		`- std::unordered_map<NodeId, std::unordered_map<uint256, CSigSharesInv, StaticSaltedHasher>> sigSharesToAnnounce;`
	`1116`	`+ std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>> sigSharesToAnnounce;`
`1117`	`1117`	`std::unordered_map<NodeId, std::vector<CSigSesAnn>> sigSessionAnnouncements;`
`1118`	`1118`
`1119`	`1119`	`auto addSigSesAnnIfNeeded = [&](NodeId nodeId, const uint256& signHash) EXCLUSIVE_LOCKS_REQUIRED(cs) {`