refactor: centralize SML cache invalidation logic

Add private helper methods InvalidateSMLCache() and InvalidateSMLCacheIfChanged()
to centralize cache invalidation logic and reduce code duplication.

This improves maintainability by:
- Centralizing cache invalidation logic in dedicated methods
- Reducing code duplication across AddMN, RemoveMN, UpdateMN, and Unserialize
- Making cache invalidation patterns consistent and easier to maintain
- Providing both unconditional and conditional invalidation helpers

The conditional invalidation method preserves the optimization in UpdateMN
where cache is only invalidated if the SML entry actually changed.

Author: PastaPastaPasta

src/evo/deterministicmns.cpp

@@ -465,10 +465,7 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn, bool fBumpTota
 
     mnMap = mnMap.set(dmn->proTxHash, dmn);
     mnInternalIdMap = mnInternalIdMap.set(dmn->GetInternalId(), dmn->proTxHash);
-    {
-        LOCK(m_cached_sml_mutex);
-        m_cached_sml = nullptr;
-    }
+    InvalidateSMLCache();
     if (fBumpTotalCount) {
         // nTotalRegisteredCount acts more like a checkpoint, not as a limit,
         nTotalRegisteredCount = std::max(dmn->GetInternalId() + 1, (uint64_t)nTotalRegisteredCount);
@@ -539,12 +536,7 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
 
     dmn->pdmnState = pdmnState;
     mnMap = mnMap.set(oldDmn.proTxHash, dmn);
-    {
-        LOCK(m_cached_sml_mutex);
-        if (m_cached_sml && oldDmn.to_sml_entry() != dmn->to_sml_entry()) {
-            m_cached_sml = nullptr;
-        }
-    }
+    InvalidateSMLCacheIfChanged(oldDmn.to_sml_entry(), dmn->to_sml_entry());
 }
 
 void CDeterministicMNList::UpdateMN(const uint256& proTxHash, const std::shared_ptr<const CDeterministicMNState>& pdmnState)
@@ -616,10 +608,7 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
 
     mnMap = mnMap.erase(proTxHash);
     mnInternalIdMap = mnInternalIdMap.erase(dmn->GetInternalId());
-    {
-        LOCK(m_cached_sml_mutex);
-        m_cached_sml = nullptr;
-    }
+    InvalidateSMLCache();
 }
 
 bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<const CBlockIndex*> pindex,

src/evo/deterministicmns.h

@@ -183,6 +183,20 @@ class CDeterministicMNList
     mutable Mutex m_cached_sml_mutex;
     mutable std::shared_ptr<const CSimplifiedMNList> m_cached_sml GUARDED_BY(m_cached_sml_mutex);
 
+    // Private helper method to invalidate SML cache
+    void InvalidateSMLCache() {
+        LOCK(m_cached_sml_mutex);
+        m_cached_sml = nullptr;
+    }
+
+    // Private helper method to conditionally invalidate SML cache if entry changed
+    void InvalidateSMLCacheIfChanged(const CSimplifiedMNListEntry& oldEntry, const CSimplifiedMNListEntry& newEntry) {
+        LOCK(m_cached_sml_mutex);
+        if (m_cached_sml && oldEntry != newEntry) {
+            m_cached_sml = nullptr;
+        }
+    }
+
 public:
     CDeterministicMNList() = default;
     explicit CDeterministicMNList(const uint256& _blockHash, int _height, uint32_t _totalRegisteredCount) :
@@ -247,10 +261,7 @@ class CDeterministicMNList
         mnMap = MnMap();
         mnUniquePropertyMap = MnUniquePropertyMap();
         mnInternalIdMap = MnInternalIdMap();
-        {
-            LOCK(m_cached_sml_mutex);
-            m_cached_sml = nullptr;
-        }
+        InvalidateSMLCache();
 
         SerializationOpBase(s, CSerActionUnserialize());