Merge #6734: perf: temporary cache for consequent calls of CDeterministicMNList for historical blocks

366cd2b refactor: clarify logic and add a named constant MINI_SNAPSHOT_INTERVAL (Konstantin Akimov)
bfca726 perf: do not create mini-snapshots during re-index (Konstantin Akimov)
38513b6 perf: temporary cache for consequent calls of CDeterministicMNList for historical blocks (Konstantin Akimov)

Pull request description:

  ## Issue being fixed or feature implemented
  Each call of `CDeterministicMNManager::GetListForBlock` for historical block can require up to 575 diff applying from snapshot.
  Consequent calls for close blocks repeat this calculation twice.

  ## What was done?
  This PR abuses `mnListsCache` by adding mini-snapshot each 32 blocks between snapshots in database (each 576 blocks).

  Downside of this solution: extra RAM usage.
  Though, this cache is cleaned every 10 seconds by `CDeterministicMNManager::DoMaintenance`, so, the RAM usage is temporary.

  ## How Has This Been Tested?
  It speeds up RPC `protx diff` up to 8x.
  `develop`:
  ```
  $ time ( for j in $(seq 500) ; do src/dash-cli protx diff $((2121000+$j)) $((2121000+$j+1)) ; done ) > /dev/null
  real    0m47,743s
  user    0m0,472s
  sys     0m1,467s
  ```

  PR:
  ```
  $ time ( for j in $(seq 500) ; do src/dash-cli protx diff $((2121000+$j)) $((2121000+$j+1)) ; done ) > /dev/null
  real    0m6,032s
  user    0m0,423s
  sys     0m1,300s
  ```

  It speeds ups blocks's Undo up to 10x; measured by calling `invalidateblock blockhash` where blockhash is distant block, far from the tip (500+).

  ## Breaking Changes
  N/A

  ## Checklist:
  - [x] I have performed a self-review of my own code
  - [x] 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:
  UdjinM6:
    LGTM, utACK 366cd2b

Tree-SHA512: 1880783916394b6f45a0e71dc59c454766bff498df62cc4642dfa4e8a53736de2ac7c180397584572b4c21a651f65b26cb832c7e4cf2d4b9599556f58bda621e

Author: PastaPastaPasta

src/evo/deterministicmns.cpp

@@ -16,6 +16,7 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <messagesigner.h>
+#include <node/blockstorage.h>
 #include <script/standard.h>
 #include <stats/client.h>
 #include <uint256.h>
@@ -779,6 +780,23 @@ CDeterministicMNList CDeterministicMNManager::GetListForBlockInternal(gsl::not_n
     for (const auto& diffIndex : listDiffIndexes) {
         const auto& diff = mnListDiffsCache.at(diffIndex->GetBlockHash());
         snapshot.ApplyDiff(diffIndex, diff);
+
+        static constexpr int MINI_SNAPSHOT_INTERVAL = 32;
+        if (!node::fReindex && snapshot.GetHeight() % MINI_SNAPSHOT_INTERVAL == 0) {
+            // Add this temporary mini-snapshot to the cache.
+            // Persistent masternode list snapshots are stored in evo-db every 576 blocks.
+            // To answer GetListForBlock() between these snapshots, the node must rebuild
+            // state by applying up to 575 diffs from the nearest persistent snapshot.
+            // If GetListForBlock() is called repeatedly in that range, the work multiplies
+            // (up to 575 diffs * number of calls).
+            // Mini-snapshots reduce this overhead by caching intermediate states
+            // every MINI_SNAPSHOT_INTERVAL blocks. Unlike persistent snapshots, these live
+            // only in memory and are cleaned up after a short time by the scheduled cleanup().
+            // There is also separate in-memory caching for the current tip and active quorums,
+            // but this mini-snapshot cache specifically speeds up repeated requests
+            // for nearby historical blocks.
+            mnListsCache.emplace(snapshot.GetBlockHash(), snapshot);
+        }
     }
 
     if (tipIndex) {