Merge #6728: refactor: removed some exceptions for circular dependencies over evo/mnhftx, evo/chainhelper and dsnotificationinterface

1f4a5a6 refactor: replace helper GetTransactionBlock to direct usage of GetTransaction (Konstantin Akimov)
3a83b06 fix: copyright for dsnotificationinterface.h (Konstantin Akimov)
c5b941f refactor: nuke dependency of node/blockstorage on evo/deterministicmns and dsnotificationinterface (Konstantin Akimov)
33020e9 refactor: replace GetTransactionBlock to direct usage of txindex (UdjinM6)
696e164 refactor: drop circular dependency over evo/chainhelper.h (Konstantin Akimov)
33f8554 refactor: drop circular dependency over evo/mnhftx.h by removing non-used include (Konstantin Akimov)

Pull request description:

  ## Issue being fixed or feature implemented
  Addressed some exception from `test/lint/lint-circular-dependencies.py`

  ## What was done?
  See commits descriptions.

  ## How Has This Been Tested?
  Updated these exception in linter:

  ```
  -    "dsnotificationinterface -> llmq/chainlocks -> node/blockstorage -> dsnotificationinterface",
  -    "evo/chainhelper -> evo/specialtxman -> evo/deterministicmns -> evo/chainhelper",
  -    "evo/chainhelper -> llmq/chainlocks -> evo/chainhelper",
  -    "evo/chainhelper -> llmq/instantsend -> evo/chainhelper",
  -    "evo/chainhelper -> masternode/payments -> governance/classes -> governance/object -> evo/chainhelper",
  -    "evo/chainhelper -> node/transaction -> node/context -> evo/chainhelper",
  -    "evo/deterministicmns -> llmq/commitment -> validation -> evo/deterministicmns",
  -    "evo/deterministicmns -> llmq/commitment -> validation -> txmempool -> evo/deterministicmns",
  -    "evo/mnhftx -> validation -> evo/mnhftx",
  +    "evo/deterministicmns -> index/txindex -> validation -> evo/deterministicmns",
  +    "evo/deterministicmns -> index/txindex -> validation -> txmempool -> evo/deterministicmns",
  ```

  ## Breaking Changes
  N/A

  ## Checklist:
  - [x] 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 1f4a5a6
  UdjinM6:
    utACK 1f4a5a6

Tree-SHA512: f4f8e674c26d6c0997438b9c740399eef3c4a623b2ff55c6fc12bcbd8a85fb9aedfdd31d46f36dc3e5f4d4b8a5b74e035b33a87a47d2fae0536503095839dc55

Author: PastaPastaPasta

src/dsnotificationinterface.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2015 The Bitcoin Core developers
+// Copyright (c) 2015 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 

src/evo/chainhelper.cpp

@@ -6,14 +6,9 @@
 
 #include <consensus/params.h>
 #include <evo/specialtxman.h>
-#include <index/txindex.h>
 #include <llmq/chainlocks.h>
 #include <llmq/instantsend.h>
 #include <masternode/payments.h>
-#include <node/transaction.h>
-#include <txmempool.h>
-
-using node::GetTransaction;
 
 CChainstateHelper::CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman,
                                      CMNHFManager& mnhfman, CGovernanceManager& govman, llmq::CInstantSendManager& isman,
@@ -64,9 +59,3 @@ bool CChainstateHelper::RemoveConflictingISLockByTx(const CTransaction& tx)
 
 bool CChainstateHelper::ShouldInstantSendRejectConflicts() const { return isman.RejectConflictingBlocks(); }
 
-std::pair<CTransactionRef, uint256> GetTransactionBlock(const uint256& hash, const CTxMemPool* const mempool)
-{
-    uint256 hashBlock{};
-    if (!g_txindex && !mempool) return {nullptr, hashBlock}; // Fast-fail as we don't have any other way to search
-    return {GetTransaction(/*block_index=*/nullptr, mempool, hash, Params().GetConsensus(), hashBlock), hashBlock};
-}

src/evo/chainhelper.h

@@ -18,7 +18,6 @@ class CGovernanceManager;
 class CSpecialTxProcessor;
 class CSporkManager;
 class CTransaction;
-class CTxMemPool;
 class uint256;
 
 namespace Consensus { struct Params; }
@@ -30,8 +29,6 @@ class CQuorumManager;
 class CQuorumSnapshotManager;
 }
 
-using CTransactionRef = std::shared_ptr<const CTransaction>;
-
 class CChainstateHelper
 {
 private:
@@ -66,8 +63,4 @@ class CChainstateHelper
     const std::unique_ptr<CSpecialTxProcessor> special_tx;
 };
 
-/* Retrieve transaction and block from txindex (or mempool) */
-std::pair</*tx=*/CTransactionRef, /*hash_block=*/uint256> GetTransactionBlock(const uint256& hash,
-                                                                              const CTxMemPool* const mempool = nullptr);
-
 #endif // BITCOIN_EVO_CHAINHELPER_H

src/evo/deterministicmns.cpp

@@ -2,13 +2,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/dmn_types.h>
 #include <evo/dmnstate.h>
 #include <evo/evodb.h>
 #include <evo/providertx.h>
 #include <evo/specialtx.h>
+#include <index/txindex.h>
 #include <llmq/commitment.h>
 #include <llmq/utils.h>
 
@@ -50,11 +50,15 @@ UniValue CDeterministicMN::ToJson() const
     obj.pushKV("collateralHash", collateralOutpoint.hash.ToString());
     obj.pushKV("collateralIndex", (int)collateralOutpoint.n);
 
-    auto [collateralTx, _] = GetTransactionBlock(collateralOutpoint.hash);
-    if (collateralTx) {
-        CTxDestination dest;
-        if (ExtractDestination(collateralTx->vout[collateralOutpoint.n].scriptPubKey, dest)) {
-            obj.pushKV("collateralAddress", EncodeDestination(dest));
+    if (g_txindex) {
+        CTransactionRef collateralTx;
+        uint256 nBlockHash;
+        g_txindex->FindTx(collateralOutpoint.hash, nBlockHash, collateralTx);
+        if (collateralTx) {
+            CTxDestination dest;
+            if (ExtractDestination(collateralTx->vout[collateralOutpoint.n].scriptPubKey, dest)) {
+                obj.pushKV("collateralAddress", EncodeDestination(dest));
+            }
         }
     }
 

src/governance/object.cpp

@@ -7,10 +7,10 @@
 #include <bls/bls.h>
 #include <chainparams.h>
 #include <core_io.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <governance/governance.h>
 #include <governance/validators.h>
+#include <index/txindex.h>
 #include <masternode/meta.h>
 #include <masternode/node.h>
 #include <masternode/sync.h>
@@ -453,8 +453,12 @@ bool CGovernanceObject::IsCollateralValid(const ChainstateManager& chainman, std
     fMissingConfirmations = false;
     uint256 nExpectedHash = GetHash();
 
-    // RETRIEVE TRANSACTION IN QUESTION
-    auto [txCollateral, nBlockHash] = GetTransactionBlock(m_obj.collateralHash);
+    CTransactionRef txCollateral;
+    uint256 nBlockHash;
+    if (g_txindex) {
+        g_txindex->FindTx(m_obj.collateralHash, nBlockHash, txCollateral);
+    }
+
     if (!txCollateral) {
         strError = strprintf("Can't find collateral tx %s", m_obj.collateralHash.ToString());
         LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError);

src/init.cpp

@@ -2327,7 +2327,31 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 
     chainman.m_load_block = std::thread(&util::TraceThread, "loadblk", [=, &args, &chainman, &node] {
-        ThreadImport(chainman, *node.dmnman, *g_ds_notification_interface, vImportFiles, node.mn_activeman.get(), args);
+        ThreadImport(chainman, vImportFiles, args);
+
+        // force UpdatedBlockTip to initialize nCachedBlockHeight for DS, MN payments and budgets
+        // but don't call it directly to prevent triggering of other listeners like zmq etc.
+        // GetMainSignals().UpdatedBlockTip(::ChainActive().Tip());
+        g_ds_notification_interface->InitializeCurrentBlockTip();
+
+        {
+            // Get all UTXOs for each MN collateral in one go so that we can fill coin cache early
+            // and reduce further locking overhead for cs_main in other parts of code including GUI
+            LogPrintf("Filling coin cache with masternode UTXOs...\n");
+            LOCK(cs_main);
+            const auto start{SteadyClock::now()};
+            const auto mnList{node.dmnman->GetListAtChainTip()};
+            mnList.ForEachMN(false, [&](auto& dmn) {
+                Coin coin;
+                GetUTXOCoin(chainman.ActiveChainstate(), dmn.collateralOutpoint, coin);
+            });
+            LogPrintf("Filling coin cache with masternode UTXOs: done in %dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
+        }
+
+        if (node.mn_activeman != nullptr) {
+            node.mn_activeman->Init(chainman.ActiveTip());
+        }
+
     });
 #ifdef ENABLE_WALLET
     if (!args.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {

src/llmq/chainlocks.cpp

@@ -10,7 +10,6 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <evo/chainhelper.h>
 #include <masternode/sync.h>
 #include <node/blockstorage.h>
 #include <node/interface_ui.h>
@@ -26,6 +25,14 @@
 
 using node::ReadBlockFromDisk;
 
+// Forward declaration to break dependency over node/transaction.h
+namespace node
+{
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
+                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+} // namespace node
+using node::GetTransaction;
+
 static bool ChainLocksSigningEnabled(const CSporkManager& sporkman)
 {
     return sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) == 0;
@@ -638,8 +645,8 @@ void CChainLocksHandler::Cleanup()
         }
     }
     for (auto it = txFirstSeenTime.begin(); it != txFirstSeenTime.end(); ) {
-        auto [tx, hashBlock] = GetTransactionBlock(it->first, &mempool);
-        if (!tx) {
+        uint256 hashBlock;
+        if (auto tx = GetTransaction(nullptr, &mempool, it->first, Params().GetConsensus(), hashBlock); !tx) {
             // tx has vanished, probably due to conflicts
             it = txFirstSeenTime.erase(it);
         } else if (!hashBlock.IsNull()) {

src/llmq/instantsend.cpp

@@ -13,7 +13,6 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <dbwrapper.h>
-#include <evo/chainhelper.h>
 #include <index/txindex.h>
 #include <masternode/sync.h>
 #include <net_processing.h>
@@ -31,6 +30,14 @@
 using node::fImporting;
 using node::fReindex;
 
+// Forward declaration to break dependency over node/transaction.h
+namespace node
+{
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
+                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+} // namespace node
+using node::GetTransaction;
+
 namespace llmq
 {
 
@@ -578,7 +585,8 @@ bool CInstantSendManager::CheckCanLock(const COutPoint& outpoint, bool printDebu
         return false;
     }
 
-    auto [tx, hashBlock] = GetTransactionBlock(outpoint.hash, &mempool);
+    uint256 hashBlock{};
+    const auto tx = GetTransaction(nullptr, &mempool, outpoint.hash, params, hashBlock);
     // this relies on enabled txindex and won't work if we ever try to remove the requirement for txindex for masternodes
     if (!tx) {
         if (printDebug) {
@@ -635,7 +643,9 @@ void CInstantSendManager::HandleNewInputLockRecoveredSig(const CRecoveredSig& re
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
-    auto [tx, hashBlock] = GetTransactionBlock(txid, &mempool);
+
+    uint256 hashBlock{};
+    const auto tx = GetTransaction(nullptr, &mempool, txid, Params().GetConsensus(), hashBlock);
     if (!tx) {
         return;
     }
@@ -1017,7 +1027,8 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, PeerManager& peerm
         return;
     }
 
-    auto [tx, hashBlock] = GetTransactionBlock(islock->txid, &mempool);
+    uint256 hashBlock{};
+    const auto tx = GetTransaction(nullptr, &mempool, islock->txid, Params().GetConsensus(), hashBlock);
     const CBlockIndex* pindexMined{nullptr};
     // we ignore failure here as we must be able to propagate the lock even if we don't have the TX locally
     if (tx && !hashBlock.IsNull()) {

src/node/blockstorage.cpp

@@ -8,12 +8,9 @@
 #include <chainparams.h>
 #include <clientversion.h>
 #include <consensus/validation.h>
-#include <dsnotificationinterface.h>
-#include <evo/deterministicmns.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <hash.h>
-#include <masternode/node.h>
 #include <pow.h>
 #include <shutdown.h>
 #include <streams.h>
@@ -825,8 +822,7 @@ struct CImportingNow {
     }
 };
 
-void ThreadImport(ChainstateManager& chainman, CDeterministicMNManager& dmnman, CDSNotificationInterface& dsnfi,
-                  std::vector<fs::path> vImportFiles, CActiveMasternodeManager* const mn_activeman, const ArgsManager& args)
+void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFiles, const ArgsManager& args)
 {
     ScheduleBatchPriority();
 
@@ -899,29 +895,6 @@ void ThreadImport(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
         }
     } // End scope of CImportingNow
 
-    // force UpdatedBlockTip to initialize nCachedBlockHeight for DS, MN payments and budgets
-    // but don't call it directly to prevent triggering of other listeners like zmq etc.
-    // GetMainSignals().UpdatedBlockTip(::ChainActive().Tip());
-    dsnfi.InitializeCurrentBlockTip();
-
-    {
-        // Get all UTXOs for each MN collateral in one go so that we can fill coin cache early
-        // and reduce further locking overhead for cs_main in other parts of code including GUI
-        LogPrintf("Filling coin cache with masternode UTXOs...\n");
-        LOCK(cs_main);
-        const auto start{SteadyClock::now()};
-        auto mnList = dmnman.GetListAtChainTip();
-        mnList.ForEachMN(false, [&](auto& dmn) {
-            Coin coin;
-            GetUTXOCoin(chainman.ActiveChainstate(), dmn.collateralOutpoint, coin);
-        });
-        LogPrintf("Filling coin cache with masternode UTXOs: done in %dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
-    }
-
-    if (mn_activeman != nullptr) {
-        mn_activeman->Init(chainman.ActiveTip());
-    }
-
     chainman.ActiveChainstate().LoadMempool(args);
 }
 } // namespace node

src/node/blockstorage.h

@@ -18,16 +18,13 @@
 
 extern RecursiveMutex cs_main;
 
-class CActiveMasternodeManager;
 class ArgsManager;
 class BlockValidationState;
 class CBlock;
 class CBlockUndo;
 class CChain;
 class CChainParams;
 class CChainState;
-class CDeterministicMNManager;
-class CDSNotificationInterface;
 class ChainstateManager;
 struct CCheckpointData;
 struct FlatFilePos;
@@ -229,8 +226,7 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus
 
 bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex);
 
-void ThreadImport(ChainstateManager& chainman, CDeterministicMNManager& dmnman, CDSNotificationInterface& dsnfi,
-                  std::vector<fs::path> vImportFiles, CActiveMasternodeManager* const mn_activeman, const ArgsManager& args);
+void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFiles, const ArgsManager& args);
 } // namespace node
 
 #endif // BITCOIN_NODE_BLOCKSTORAGE_H