Merge #6851: refactor: introduce new helpers Uint256HashMap, Uint256HashSet, Uint256LruHashMap

c461dcc fix: review comments (Konstantin Akimov)
46a28e6 fmt: apply clang-format (Konstantin Akimov)
c452f88 refactor: leftover usages that has not been replaced by automatic script (Konstantin Akimov)
85e6af4 refactor: use Uint256LruHashMap all overcodebase (Konstantin Akimov)
c8c6d29 refactor: use Uint256HashMap all over codebase (Konstantin Akimov)
3aaf330 refactor: use Uint256HashSet all over codebase (Konstantin Akimov)
d7cd9ab refactor: define helpers Uint256HashMap, Uint256HashSet, Uint256LruHashMap for code simplification (Konstantin Akimov)

Pull request description:

  ## Issue being fixed or feature implemented

  Instead typing `std::unordered_map<uint256, CDeterministicMNList, StaticSaltedHasher> mnListsCache` better to just write `Uint256HashMap<CDeterministicMNList> mnListsCache` to minimize a boiler code. This PR aims to replace #6839, but this PR reduces scope significantly, no extra header is introduced.

  ## What was done?
  Main idea is authored by kwvg's PR:

      template <typename T>
      using Uint256HashMap = std::unordered_map<uint256, T, StaticSaltedHasher>;

  These helpers are used to prepare a PR:

      find src/ -name '*.cpp' -exec sed -i 's/std::unordered_set<uint256, StaticSaltedHasher>/Uint256HashSet/' {} \;
      find src/ -name '*.cpp' -exec sed -i 's/std::unordered_map<uint256, \([a-zA-Z0-9:]*\), StaticSaltedHasher>/Uint256HashMap<\1>/' {} \;
      find src/ -name '*.cpp' -exec sed -i 's/unordered_lru_cache<uint256, \([a-zA-Z0-9:]*\), StaticSaltedHasher>/Uint256LruHashMap<\1>/' {} \;

  Leftover changes are done manually.

  Please, note, that compilation time is not affected by including `<unordered_set>` and `<unordered_map>` because they are already included indirectly by chain `<saltedhasher.h> -> <hash.h> -> <serialize.h>`

  ## How Has This Been Tested?
  Grep all over codebase by `StaticSaltedHasher`

  ## Breaking Changes
  N/A

  ## Checklist:
  - [ ] I have performed a self-review of my own code
  - [ ] I have commented my code, particularly in hard-to-understand areas
  - [ ] I have added or updated relevant unit/integration/functional/e2e tests
  - [ ] I have made corresponding changes to the documentation
  - [x] I have assigned this pull request to a milestone

ACKs for top commit:
  kwvg:
    utACK c461dcc

Tree-SHA512: 2d8d0722554f5f89102d4d5380bfda01f2214cf8da82dbf300753e373a0b78ef6248ca626bd07f5bb467c5670ae9733d34aa020a1d268d3074dbc77fc5fc953b

Author: PastaPastaPasta

src/chainlock/chainlock.cpp

@@ -114,7 +114,7 @@ chainlock::ChainLockSig CChainLocksHandler::GetBestChainLock() const
     return bestChainLock;
 }
 
-void CChainLocksHandler::UpdateTxFirstSeenMap(const std::unordered_set<uint256, StaticSaltedHasher>& tx, const int64_t& time)
+void CChainLocksHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time)
 {
     AssertLockNotHeld(cs);
     LOCK(cs);

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);
 
@@ -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 std::unordered_set<uint256, StaticSaltedHasher>& 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

src/chainlock/signing.cpp

@@ -158,7 +158,7 @@ void ChainLockSigner::UpdateBlockHashTxidMap(const uint256& hash, const std::vec
     if (it == blockTxs.end()) {
         // We must create this entry even if there are no lockable transactions in the block, so that TrySignChainTip
         // later knows about this block
-        it = blockTxs.emplace(hash, std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>()).first;
+        it = blockTxs.emplace(hash, std::make_shared<Uint256HashSet>()).first;
     }
     auto& txids = *it->second;
     for (const auto& tx : vtx) {
@@ -200,7 +200,7 @@ ChainLockSigner::BlockTxs::mapped_type ChainLockSigner::GetBlockTxs(const uint25
                 return nullptr;
             }
 
-            ret = std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>();
+            ret = std::make_shared<Uint256HashSet>();
             for (const auto& tx : block.vtx) {
                 if (tx->IsCoinBase() || tx->vin.empty()) {
                     continue;
@@ -243,10 +243,10 @@ MessageProcessingResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CReco
     return m_clhandler.ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
 }
 
-std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> ChainLockSigner::Cleanup()
+std::vector<std::shared_ptr<Uint256HashSet>> ChainLockSigner::Cleanup()
 {
     AssertLockNotHeld(cs_signer);
-    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> removed;
+    std::vector<std::shared_ptr<Uint256HashSet>> removed;
     LOCK2(::cs_main, cs_signer);
     for (auto it = blockTxs.begin(); it != blockTxs.end();) {
         const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);

src/chainlock/signing.h

@@ -34,7 +34,7 @@ class ChainLockSignerParent
     virtual bool IsEnabled() const = 0;
     virtual bool IsTxSafeForMining(const uint256& txid) const = 0;
     [[nodiscard]] virtual MessageProcessingResult ProcessNewChainLock(NodeId from, const ChainLockSig& clsig, const uint256& hash) = 0;
-    virtual void UpdateTxFirstSeenMap(const std::unordered_set<uint256, StaticSaltedHasher>& tx, const int64_t& time) = 0;
+    virtual void UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time) = 0;
 };
 
 class ChainLockSigner final : public llmq::CRecoveredSigsListener
@@ -52,7 +52,7 @@ class ChainLockSigner final : public llmq::CRecoveredSigsListener
     struct BlockHasher {
         size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
     };
-    using BlockTxs = std::unordered_map<uint256, std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>, BlockHasher>;
+    using BlockTxs = std::unordered_map<uint256, std::shared_ptr<Uint256HashSet>, BlockHasher>;
 
 private:
     mutable Mutex cs_signer;
@@ -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<std::unordered_set<uint256, StaticSaltedHasher>>> 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)

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, unordered_lru_cache<uint256, std::pair<uint256, int>, StaticSaltedHasher>> 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);
 

src/evo/creditpool.cpp

@@ -68,8 +68,8 @@ static std::optional<CreditPoolDataPerBlock> GetCreditDataFromBlock(const gsl::n
     CreditPoolDataPerBlock blockData;
 
     static Mutex cache_mutex;
-    static unordered_lru_cache<uint256, CreditPoolDataPerBlock, StaticSaltedHasher> 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;
     }

src/evo/creditpool.h

@@ -111,7 +111,7 @@ class CCreditPoolManager
 private:
     static constexpr size_t CreditPoolCacheSize = 1000;
     Mutex cache_mutex;
-    unordered_lru_cache<uint256, CCreditPool, StaticSaltedHasher> creditPoolCache GUARDED_BY(cache_mutex) {CreditPoolCacheSize};
+    Uint256LruHashMap<CCreditPool> creditPoolCache GUARDED_BY(cache_mutex){CreditPoolCacheSize};
 
     CEvoDB& evoDb;
 

src/evo/deterministicmns.h

@@ -628,8 +628,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};
 

src/evo/mnhftx.h

@@ -100,7 +100,7 @@ class CMNHFManager : public AbstractEHFManager
     static constexpr size_t MNHFCacheSize = 1000;
     Mutex cs_cache;
     // versionBit <-> height
-    unordered_lru_cache<uint256, Signals, StaticSaltedHasher> mnhfCache GUARDED_BY(cs_cache) {MNHFCacheSize};
+    Uint256LruHashMap<Signals> mnhfCache GUARDED_BY(cs_cache){MNHFCacheSize};
 
 public:
     explicit CMNHFManager(CEvoDB& evoDb);

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) {
@@ -359,7 +359,7 @@ std::vector<uint256> CInstantSendDb::RemoveChainedInstantSendLocks(const uint256
     std::vector<uint256> result;
 
     std::vector<uint256> stack;
-    std::unordered_set<uint256, StaticSaltedHasher> added;
+    Uint256HashSet added;
     stack.emplace_back(txid);
 
     CDBBatch batch(*db);