test: add comprehensive unit tests for SML caching mechanism

Add extensive unit tests to verify the SML caching functionality:

- Test basic cache functionality and cache hits
- Test cache invalidation on AddMN operations
- Test cache invalidation on RemoveMN operations
- Test conditional cache invalidation on UpdateMN operations
- Test cache behavior with copy constructor and assignment operator

These tests ensure the cache works correctly and efficiently, validating:
- Cache is properly shared when no changes occur
- Cache is invalidated when MN list changes
- Cache preserves optimization in UpdateMN when SML entry doesn't change
- Cache is properly copied/shared during object copying

This provides comprehensive coverage of the caching mechanism's
correctness.

Author: PastaPastaPasta

src/test/evo_deterministicmns_tests.cpp

@@ -8,6 +8,12 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
+#include <evo/deterministicmns.h>
+#include <evo/providertx.h>
+#include <evo/simplifiedmns.h>
+#include <evo/specialtx.h>
+#include <llmq/context.h>
+#include <llmq/instantsend.h>
 #include <messagesigner.h>
 #include <netbase.h>
 #include <node/transaction.h>
@@ -20,14 +26,10 @@
 #include <txmempool.h>
 #include <validation.h>
 
-#include <evo/deterministicmns.h>
-#include <evo/providertx.h>
-#include <evo/specialtx.h>
-#include <llmq/context.h>
-#include <llmq/instantsend.h>
-
 #include <boost/test/unit_test.hpp>
 
+#include <vector>
+
 using node::GetTransaction;
 
 using SimpleUTXOMap = std::map<COutPoint, std::pair<int, CAmount>>;
@@ -836,6 +838,98 @@ void FuncVerifyDB(TestChainSetup& setup)
                                        chainman.ActiveChainstate().CoinsTip(), *(setup.m_node.evodb), 4, 2));
 }
 
+static CDeterministicMNCPtr create_mock_mn(uint64_t internal_id)
+{
+    // Create a mock MN
+    CKey ownerKey;
+    ownerKey.MakeNewKey(true);
+    CBLSSecretKey operatorKey;
+    operatorKey.MakeNewKey();
+
+    auto dmnState = std::make_shared<CDeterministicMNState>();
+    dmnState->confirmedHash = GetRandHash();
+    dmnState->keyIDOwner = ownerKey.GetPubKey().GetID();
+    dmnState->pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
+    dmnState->keyIDVoting = ownerKey.GetPubKey().GetID();
+    dmnState->netInfo = NetInfoInterface::MakeNetInfo(
+        ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false));
+    BOOST_CHECK_EQUAL(dmnState->netInfo->AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
+
+    auto dmn = std::make_shared<CDeterministicMN>(internal_id, MnType::Regular);
+    dmn->proTxHash = GetRandHash();
+    dmn->collateralOutpoint = COutPoint(GetRandHash(), 0);
+    dmn->nOperatorReward = 0;
+    dmn->pdmnState = dmnState;
+
+    return dmn;
+}
+
+static void SmlCache(TestChainSetup& setup)
+{
+    BOOST_CHECK(setup.m_node.dmnman != nullptr);
+
+    // Create empty list and verify SML cache
+    CDeterministicMNList emptyList(uint256(), 0, 0);
+    auto sml_empty = emptyList.to_sml();
+
+    // Should return the same cached object
+    BOOST_CHECK(sml_empty == emptyList.to_sml());
+
+    // Should contain empty list
+    BOOST_CHECK_EQUAL(sml_empty->mnList.size(), 0);
+
+    // Copy list should return the same cached object
+    CDeterministicMNList mn_list_1(emptyList);
+    BOOST_CHECK(sml_empty == mn_list_1.to_sml());
+
+    // Assigning list should return the same cached object
+    CDeterministicMNList mn_list_2 = emptyList;
+    BOOST_CHECK(sml_empty == mn_list_2.to_sml());
+
+    auto dmn = create_mock_mn(1);
+
+    // Add MN - should invalidate cache
+    mn_list_1.AddMN(dmn, true);
+    auto sml_add = mn_list_1.to_sml();
+
+    // Cache should be invalidated, so different pointer but equal content after regeneration
+    BOOST_CHECK(sml_empty != sml_add); // Different pointer (cache invalidated)
+
+    BOOST_CHECK_EQUAL(sml_add->mnList.size(), 1); // Should contain the added MN
+
+    {
+        // Remove MN - should invalidate cache
+        CDeterministicMNList mn_list(mn_list_1);
+        BOOST_CHECK(mn_list_1.to_sml() == mn_list.to_sml());
+
+        mn_list.RemoveMN(dmn->proTxHash);
+        auto sml_remove = mn_list.to_sml();
+
+        // Cache should be invalidated
+        BOOST_CHECK(sml_remove != sml_add);
+        BOOST_CHECK(sml_remove != sml_empty);
+        BOOST_CHECK_EQUAL(sml_remove->mnList.size(), 0); // Should be empty after removal
+    }
+
+    // Start with a list containing one MN mn_list_1
+    // Test 1: Update with same SML entry data - cache should NOT be invalidated
+    auto unchangedState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
+    unchangedState->nPoSePenalty += 10;
+    mn_list_1.UpdateMN(*dmn, unchangedState);
+
+    // Cache should NOT be invalidated since SML entry didn't change
+    BOOST_CHECK(sml_add == mn_list_1.to_sml()); // Same pointer (cache preserved)
+
+    // Test 2: Update with different SML entry data - cache SHOULD be invalidated
+    auto changedState = std::make_shared<CDeterministicMNState>(*unchangedState);
+    changedState->pubKeyOperator.Set(CBLSPublicKey{}, bls::bls_legacy_scheme.load());
+    mn_list_1.UpdateMN(*dmn, changedState);
+
+    // Cache should be invalidated since SML entry changed
+    BOOST_CHECK(sml_add != mn_list_1.to_sml());
+    BOOST_CHECK_EQUAL(mn_list_1.to_sml()->mnList.size(), 1); // Still one MN but with updated data
+}
+
 BOOST_AUTO_TEST_SUITE(evo_dip3_activation_tests)
 
 struct TestChainDIP3BeforeActivationSetup : public TestChainSetup {
@@ -938,4 +1032,16 @@ BOOST_AUTO_TEST_CASE(verify_db_legacy)
     FuncVerifyDB(setup);
 }
 
+BOOST_AUTO_TEST_CASE(test_sml_cache_legacy)
+{
+    TestChainDIP3Setup setup;
+    SmlCache(setup);
+}
+
+BOOST_AUTO_TEST_CASE(test_sml_cache_basic)
+{
+    TestChainV19Setup setup;
+    SmlCache(setup);
+}
+
 BOOST_AUTO_TEST_SUITE_END()