refactor: drop dependency SML on DMN

Author: knst

src/evo/deterministicmns.cpp

@@ -37,6 +37,14 @@ uint64_t CDeterministicMN::GetInternalId() const
     return internalId;
 }
 
+CSimplifiedMNListEntry CDeterministicMN::to_sml_entry() const
+{
+    const CDeterministicMNState& state{*pdmnState};
+    return CSimplifiedMNListEntry(proTxHash, state.confirmedHash, state.netInfo, state.pubKeyOperator,
+                                  state.keyIDVoting, !state.IsBanned(), state.platformHTTPPort, state.platformNodeID,
+                                  state.scriptPayout, state.scriptOperatorPayout, state.nVersion, nType);
+}
+
 std::string CDeterministicMN::ToString() const
 {
     return strprintf("CDeterministicMN(proTxHash=%s, collateralOutpoint=%s, nOperatorReward=%f, state=%s", proTxHash.ToString(), collateralOutpoint.ToStringShort(), (double)nOperatorReward / 100, pdmnState->ToString());
@@ -259,11 +267,18 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl
     return result;
 }
 
-gsl::not_null<std::shared_ptr<const CSimplifiedMNList>> CDeterministicMNList::GetSML() const
+gsl::not_null<std::shared_ptr<const CSimplifiedMNList>> CDeterministicMNList::to_sml() const
 {
     if (!m_cached_sml) {
-        m_cached_sml = std::make_shared<const CSimplifiedMNList>(*this);
+        std::vector<std::unique_ptr<CSimplifiedMNListEntry>> sml_entries;
+        sml_entries.reserve(mnMap.size());
+
+        ForEachMN(false, [&sml_entries](auto& dmn) {
+            sml_entries.emplace_back(std::make_unique<CSimplifiedMNListEntry>(dmn.to_sml_entry()));
+        });
+        m_cached_sml = std::make_shared<CSimplifiedMNList>(std::move(sml_entries));
     }
+
     return m_cached_sml;
 }
 
@@ -524,7 +539,7 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
 
     dmn->pdmnState = pdmnState;
     mnMap = mnMap.set(oldDmn.proTxHash, dmn);
-    if (m_cached_sml && CSimplifiedMNListEntry{oldDmn} != CSimplifiedMNListEntry{*dmn}) {
+    if (m_cached_sml && oldDmn.to_sml_entry() != dmn->to_sml_entry()) {
         m_cached_sml = nullptr;
     }
 }
@@ -618,7 +633,7 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
     int nHeight = pindex->nHeight;
 
     try {
-        newList.GetSML(); // to fullfill cache of SML
+        newList.to_sml(); // to fullfill cache of SML
 
         LOCK(cs);
 

src/evo/deterministicmns.h

@@ -31,6 +31,7 @@ class CBlockIndex;
 class CCoinsViewCache;
 class CEvoDB;
 class CSimplifiedMNList;
+class CSimplifiedMNListEntry;
 class TxValidationState;
 
 extern RecursiveMutex cs_main;
@@ -80,6 +81,7 @@ class CDeterministicMN
 
     [[nodiscard]] uint64_t GetInternalId() const;
 
+    [[nodiscard]] CSimplifiedMNListEntry to_sml_entry() const;
     [[nodiscard]] std::string ToString() const;
     [[nodiscard]] UniValue ToJson() const;
 };
@@ -326,7 +328,7 @@ class CDeterministicMNList
     /**
      * Calculates CSimplifiedMNList for current list and cache it
      */
-    gsl::not_null<std::shared_ptr<const CSimplifiedMNList>> GetSML() const;
+    gsl::not_null<std::shared_ptr<const CSimplifiedMNList>> to_sml() const;
 
     /**
      * Calculates the maximum penalty which is allowed at the height of this MN list. It is dynamic and might change

src/evo/simplifiedmns.cpp

@@ -4,28 +4,35 @@
 
 #include <evo/simplifiedmns.h>
 
+#include <clientversion.h>
 #include <consensus/merkle.h>
-#include <evo/deterministicmns.h>
 #include <key_io.h>
 #include <pubkey.h>
 #include <serialize.h>
+#include <sync.h>
 #include <univalue.h>
+#include <util/time.h>
 #include <util/underlying.h>
 #include <version.h>
 
-CSimplifiedMNListEntry::CSimplifiedMNListEntry(const CDeterministicMN& dmn) :
-    proRegTxHash(dmn.proTxHash),
-    confirmedHash(dmn.pdmnState->confirmedHash),
-    netInfo(dmn.pdmnState->netInfo),
-    pubKeyOperator(dmn.pdmnState->pubKeyOperator),
-    keyIDVoting(dmn.pdmnState->keyIDVoting),
-    isValid(!dmn.pdmnState->IsBanned()),
-    platformHTTPPort(dmn.pdmnState->platformHTTPPort),
-    platformNodeID(dmn.pdmnState->platformNodeID),
-    scriptPayout(dmn.pdmnState->scriptPayout),
-    scriptOperatorPayout(dmn.pdmnState->scriptOperatorPayout),
-    nVersion(dmn.pdmnState->nVersion),
-    nType(dmn.nType)
+CSimplifiedMNListEntry::CSimplifiedMNListEntry(const uint256& proreg_tx_hash, const uint256& confirmed_hash,
+                                               const std::shared_ptr<NetInfoInterface>& net_info,
+                                               const CBLSLazyPublicKey& pubkey_operator, const CKeyID& keyid_voting,
+                                               bool is_valid, uint16_t platform_http_port,
+                                               const uint160& platform_node_id, const CScript& script_payout,
+                                               const CScript& script_operator_payout, uint16_t version, MnType type) :
+    proRegTxHash(proreg_tx_hash),
+    confirmedHash(confirmed_hash),
+    netInfo(net_info),
+    pubKeyOperator(pubkey_operator),
+    keyIDVoting(keyid_voting),
+    isValid(is_valid),
+    platformHTTPPort(platform_http_port),
+    platformNodeID(platform_node_id),
+    scriptPayout(script_payout),
+    scriptOperatorPayout(script_operator_payout),
+    nVersion(version),
+    nType(type)
 {
 }
 
@@ -57,24 +64,9 @@ std::string CSimplifiedMNListEntry::ToString() const
                      operatorPayoutAddress, platformHTTPPort, platformNodeID.ToString(), netInfo->ToString());
 }
 
-CSimplifiedMNList::CSimplifiedMNList(const std::vector<CSimplifiedMNListEntry>& smlEntries)
+CSimplifiedMNList::CSimplifiedMNList(std::vector<std::unique_ptr<CSimplifiedMNListEntry>>&& smlEntries)
 {
-    mnList.reserve(smlEntries.size());
-    for (const auto& entry : smlEntries) {
-        mnList.emplace_back(std::make_unique<CSimplifiedMNListEntry>(entry));
-    }
-
-    std::sort(mnList.begin(), mnList.end(), [&](const std::unique_ptr<CSimplifiedMNListEntry>& a, const std::unique_ptr<CSimplifiedMNListEntry>& b) {
-        return a->proRegTxHash.Compare(b->proRegTxHash) < 0;
-    });
-}
-
-CSimplifiedMNList::CSimplifiedMNList(const CDeterministicMNList& dmnList)
-{
-    mnList.reserve(dmnList.GetAllMNsCount());
-    dmnList.ForEachMN(false, [this](auto& dmn) {
-        mnList.emplace_back(std::make_unique<CSimplifiedMNListEntry>(dmn));
-    });
+    mnList = std::move(smlEntries);
 
     std::sort(mnList.begin(), mnList.end(), [&](const std::unique_ptr<CSimplifiedMNListEntry>& a, const std::unique_ptr<CSimplifiedMNListEntry>& b) {
         return a->proRegTxHash.Compare(b->proRegTxHash) < 0;
@@ -102,7 +94,8 @@ bool CSimplifiedMNList::operator==(const CSimplifiedMNList& rhs) const
             );
 }
 
-bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, const CDeterministicMNList& mn_list, BlockValidationState& state)
+bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, std::shared_ptr<const CSimplifiedMNList> sml,
+                              BlockValidationState& state)
 {
     try {
         static std::atomic<int64_t> nTimeMerkle = 0;
@@ -115,7 +108,6 @@ bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, const CDeterministicMNList
         static uint256 merkleRootCached GUARDED_BY(cached_mutex);
         static bool mutatedCached GUARDED_BY(cached_mutex){false};
 
-        std::shared_ptr<const CSimplifiedMNList> sml{mn_list.GetSML()};
         LOCK(cached_mutex);
         if (sml == cached_sml || *sml == *cached_sml) {
             merkleRootRet = merkleRootCached;

src/evo/simplifiedmns.h

@@ -14,16 +14,10 @@
 #include <pubkey.h>
 #include <util/pointer.h>
 
-class UniValue;
-class CDeterministicMN;
-class CDeterministicMNList;
-class ChainstateManager;
+#include <memory>
+#include <vector>
 
-namespace llmq {
-class CFinalCommitment;
-class CQuorumBlockProcessor;
-class CQuorumManager;
-} // namespace llmq
+class UniValue;
 
 class CSimplifiedMNListEntry
 {
@@ -42,7 +36,11 @@ class CSimplifiedMNListEntry
     MnType nType{MnType::Regular};
 
     CSimplifiedMNListEntry() = default;
-    explicit CSimplifiedMNListEntry(const CDeterministicMN& dmn);
+    CSimplifiedMNListEntry(const uint256& proreg_tx_hash, const uint256& confirmed_hash,
+                           const std::shared_ptr<NetInfoInterface>& net_info, const CBLSLazyPublicKey& pubkey_operator,
+                           const CKeyID& keyid_voting, bool is_valid, uint16_t platform_http_port,
+                           const uint160& platform_node_id, const CScript& script_payout,
+                           const CScript& script_operator_payout, uint16_t version, MnType type);
 
     bool operator==(const CSimplifiedMNListEntry& rhs) const
     {
@@ -101,15 +99,15 @@ class CSimplifiedMNList
     std::vector<std::unique_ptr<CSimplifiedMNListEntry>> mnList;
 
     CSimplifiedMNList() = default;
-    explicit CSimplifiedMNList(const CDeterministicMNList& dmnList);
 
     // This constructor from std::vector is used in unit-tests
-    explicit CSimplifiedMNList(const std::vector<CSimplifiedMNListEntry>& smlEntries);
+    explicit CSimplifiedMNList(std::vector<std::unique_ptr<CSimplifiedMNListEntry>>&& smlEntries);
 
     uint256 CalcMerkleRoot(bool* pmutated = nullptr) const;
     bool operator==(const CSimplifiedMNList& rhs) const;
 };
 
-bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, const CDeterministicMNList& sml, BlockValidationState& state);
+bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, std::shared_ptr<const CSimplifiedMNList> sml,
+                              BlockValidationState& state);
 
 #endif // BITCOIN_EVO_SIMPLIFIEDMNS_H

src/evo/smldiff.cpp

@@ -127,11 +127,11 @@ CSimplifiedMNListDiff BuildSimplifiedDiff(const CDeterministicMNList& from, cons
     to.ForEachMN(false, [&](const auto& toPtr) {
         auto fromPtr = from.GetMN(toPtr.proTxHash);
         if (fromPtr == nullptr) {
-            CSimplifiedMNListEntry sme(toPtr);
+            CSimplifiedMNListEntry sme{toPtr.to_sml_entry()};
             diffRet.mnList.push_back(std::move(sme));
         } else {
-            CSimplifiedMNListEntry sme1(toPtr);
-            CSimplifiedMNListEntry sme2(*fromPtr);
+            CSimplifiedMNListEntry sme1{toPtr.to_sml_entry()};
+            CSimplifiedMNListEntry sme2(fromPtr->to_sml_entry());
             if ((sme1 != sme2) || (extended && (sme1.scriptPayout != sme2.scriptPayout ||
                                                 sme1.scriptOperatorPayout != sme2.scriptOperatorPayout))) {
                 diffRet.mnList.push_back(std::move(sme1));

src/evo/specialtxman.cpp

@@ -608,7 +608,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
                      nTimeDMN * 0.000001);
 
             uint256 calculatedMerkleRoot;
-            if (!CalcCbTxMerkleRootMNList(calculatedMerkleRoot, mn_list, state)) {
+            if (!CalcCbTxMerkleRootMNList(calculatedMerkleRoot, mn_list.to_sml(), state)) {
                 // pass the state returned by the function above
                 return false;
             }

src/node/miner.cpp

@@ -291,7 +291,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         if (!m_chain_helper.special_tx->BuildNewListFromBlock(*pblock, pindexPrev, m_chainstate.CoinsTip(), true, state, mn_list)) {
             throw std::runtime_error(strprintf("%s: BuildNewListFromBlock failed: %s", __func__, state.ToString()));
         }
-        if (!CalcCbTxMerkleRootMNList(cbTx.merkleRootMNList, mn_list, state)) {
+        if (!CalcCbTxMerkleRootMNList(cbTx.merkleRootMNList, mn_list.to_sml(), state)) {
             throw std::runtime_error(strprintf("%s: CalcCbTxMerkleRootMNList failed: %s", __func__, state.ToString()));
         }
         if (fDIP0008Active_context) {

src/test/evo_simplifiedmns_tests.cpp

@@ -16,7 +16,7 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
 {
     //TODO: Provide raw data for basic scheme as well
     bls::bls_legacy_scheme.store(true);
-    std::vector<CSimplifiedMNListEntry> entries;
+    std::vector<std::unique_ptr<CSimplifiedMNListEntry>> entries;
     for (size_t i = 1; i < 16; i++) {
         CSimplifiedMNListEntry smle;
         smle.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
         smle.keyIDVoting.SetHex(strprintf("%040x", i));
         smle.isValid = true;
 
-        entries.emplace_back(smle);
+        entries.emplace_back(std::make_unique<CSimplifiedMNListEntry>(smle));
     }
 
     std::vector<std::string> expectedHashes = {
@@ -56,13 +56,13 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
     std::vector<std::string> calculatedHashes;
 
     for (auto& smle : entries) {
-        calculatedHashes.emplace_back(smle.CalcHash().ToString());
+        calculatedHashes.emplace_back(smle->CalcHash().ToString());
         //printf("\"%s\",\n", calculatedHashes.back().c_str());
     }
 
     BOOST_CHECK(expectedHashes == calculatedHashes);
 
-    CSimplifiedMNList sml(entries);
+    CSimplifiedMNList sml{std::move(entries)};
 
     std::string expectedMerkleRoot = "0bae2176078cf42fa3e1fda761d4255d1c1c54777c6a793d0ab2b07c85ed4022";
     std::string calculatedMerkleRoot = sml.CalcMerkleRoot(nullptr).ToString();

src/test/util/setup_common.cpp

@@ -519,7 +519,7 @@ CBlock TestChainSetup::CreateBlock(
         if (!chainstate.ChainHelper().special_tx->BuildNewListFromBlock(block, chainstate.m_chain.Tip(), chainstate.CoinsTip(), true, state, mn_list)) {
             Assert(false);
         }
-        if (!CalcCbTxMerkleRootMNList(cbTx->merkleRootMNList, mn_list, state)) {
+        if (!CalcCbTxMerkleRootMNList(cbTx->merkleRootMNList, mn_list.to_sml(), state)) {
             Assert(false);
         }
         if (!CalcCbTxMerkleRootQuorums(block, chainstate.m_chain.Tip(), *m_node.llmq_ctx->quorum_block_processor, cbTx->merkleRootQuorums, state)) {

test/lint/lint-circular-dependencies.py

@@ -37,7 +37,6 @@
     "evo/chainhelper -> evo/specialtxman -> validation -> evo/chainhelper",
     "evo/deterministicmns -> index/txindex -> validation -> evo/deterministicmns",
     "evo/deterministicmns -> index/txindex -> validation -> txmempool -> evo/deterministicmns",
-    "evo/deterministicmns -> evo/simplifiedmns -> evo/deterministicmns",
     "evo/netinfo -> evo/providertx -> evo/netinfo",
     "evo/smldiff -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/smldiff",
     "core_io -> evo/assetlocktx -> llmq/signing -> net_processing -> evo/smldiff -> core_io",