Merge dashpay#5871: refactor: alias Dash-specific globals to NodeContext, reduce globals use in GUI, interface, RPC and test logic

fb272dd refactor: use NodeContext members instead of globals in interface logic (Kittywhiskers Van Gogh)
aba57ce qt: add interface for CGovernanceObject querying (Kittywhiskers Van Gogh)
8d73cec refactor: reduce globals use in RPC and bench, use LLMQContext members (Kittywhiskers Van Gogh)
e8270ca refactor: use NodeContext members instead of globals in RPC logic (Kittywhiskers Van Gogh)
2efebca refactor: use aliases of globals in unit tests (Kittywhiskers Van Gogh)
89f41fa refactor: dereference CDeterministicMNManager instance before use (Kittywhiskers Van Gogh)
d3dfdf3 refactor: use aliases of globals in initialization logic (Kittywhiskers Van Gogh)
bb7fe58 refactor: rename creditPoolManager to cpoolman in NodeContext, fix order (Kittywhiskers Van Gogh)
6f08e10 refactor: remove extraneous creditPoolManager initialization (Kittywhiskers Van Gogh)
d136c40 refactor: add aliases for Dash-specific global pointers in NodeContext (Kittywhiskers Van Gogh)

Pull request description:

  ## Additional Notes

  * In some limited circumstances, we need to pass a reference to a smart pointer _before_ it is initialized. This is permissible if we know for sure that the pointer will be dereferenced _after_ it is initialized (usually, by `assert`'ing `!= nullptr`). This requires us to pass the const ref of the smart pointer object, to ensure that when dereferenced, we get access to the updated value that is set later on the initialization sequence.

    This means we cannot use the bare pointer alias as an argument as it would remain `nullptr` and will not be updated.

    Currently known examples are:
    * `CChainState` through `ChainstateManager::InitializeChainstate`
      * `llmq::CChainLocksHandler` (as `llmq::chainLocksHandler`)
      * `llmq::CInstantSendManager` (as `llmq::quorumInstantSendManager`)
      * `llmq::CQuorumBlockProcessor` (as `llmq::quorumBlockProcessor`)
    * `CDSNotificationInterface`
      * `CDeterministicMNManager` (as `deterministicMNManager`)
      * `CJContext` (as `NodeContext::cj_ctx`)
      * `LLMQContext` (as `NodeContext::llmq_ctx`)

  * We can verify the absence of globals in GUI, interface, RPC and test logic with the commands below (the above caveat applies)

    ```bash
    $ function make_filter() { echo "$1->|\*$1|::$1"; }
    $ PROHIBITED_TERMS="$(make_filter creditPoolManager)|$(make_filter deterministicMNManager)|$(make_filter dstxManager)|$(make_filter governance)|$(make_filter mmetaman)|$(make_filter netfulfilledman)|$(make_filter sporkManager)";
    $ PROHIBITED_LLMQ_TERMS="$(make_filter quorumBlockProcessor)|$(make_filter quorumManager)|$(make_filter chainLocksHandler)|$(make_filter quorumInstantSendManager)";
    $ grep -E "$PROHIBITED_TERMS|$PROHIBITED_LLMQ_TERMS" src/bench/*.{cpp,h} src/node/interfaces.cpp src/qt/*.{cpp,h} src/qt/test/*.{cpp,h} src/rpc/*.{cpp,h} src/test/*.{cpp,h} src/wallet/rpc*.{cpp,h};
    src/test/validation_chainstate_tests.cpp:    CChainState& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.mnhf_manager, *m_node.evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor));
    src/test/validation_chainstatemanager_tests.cpp:    CChainState& c1 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(&mempool, *m_node.mnhf_manager, evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor));
    src/test/validation_chainstatemanager_tests.cpp:        &mempool, *m_node.mnhf_manager, evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor,
    src/test/validation_chainstatemanager_tests.cpp:    CChainState& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.mnhf_manager, evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor));
    src/test/validation_chainstatemanager_tests.cpp:    CChainState& c2 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.mnhf_manager, evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor, GetRandHash()));
    src/test/validation_flush_tests.cpp:    CChainState chainstate(&mempool, blockman, *m_node.mnhf_manager, *m_node.evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor);
    ```

  * We can also check the usage of globals in (test) initialization logic (it will also include all the actual (de)initialization logic and any usage of the bare pointer alias if the name of the global and the alias are the same, as is the case with `netfulfilledman`)

    ```bash
    $ grep -E "$PROHIBITED_TERMS|$PROHIBITED_LLMQ_TERMS" src/init.cpp src/test/util/setup_common.cpp;
    src/init.cpp:    ::netfulfilledman.reset();
    src/init.cpp:    ::mmetaman.reset();
    src/init.cpp:    ::dstxManager.reset();
    src/init.cpp:    ::sporkManager.reset();
    src/init.cpp:    ::governance.reset();
    src/init.cpp:    assert(!::governance);
    src/init.cpp:    ::governance = std::make_unique<CGovernanceManager>();
    src/init.cpp:    node.govman = ::governance.get();
    src/init.cpp:    assert(!::sporkManager);
    src/init.cpp:    ::sporkManager = std::make_unique<CSporkManager>();
    src/init.cpp:    node.sporkman = ::sporkManager.get();
    src/init.cpp:        *node.connman, *node.mn_sync, ::deterministicMNManager, *node.govman, node.llmq_ctx, node.cj_ctx
    src/init.cpp:                chainman.InitializeChainstate(Assert(node.mempool.get()), *node.mnhf_manager, *node.evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor);
    src/init.cpp:    assert(!::dstxManager);
    src/init.cpp:    ::dstxManager = std::make_unique<CDSTXManager>();
    src/init.cpp:    node.dstxman = ::dstxManager.get();
    src/init.cpp:    assert(!::mmetaman);
    src/init.cpp:    ::mmetaman = std::make_unique<CMasternodeMetaMan>(fLoadCacheFiles);
    src/init.cpp:    node.mn_metaman = ::mmetaman.get();
    src/init.cpp:    assert(!::netfulfilledman);
    src/init.cpp:    ::netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(fLoadCacheFiles);
    src/init.cpp:    node.netfulfilledman = ::netfulfilledman.get();
    src/init.cpp:    if (!node.netfulfilledman->IsValid()) {
    src/test/util/setup_common.cpp:    ::deterministicMNManager = std::make_unique<CDeterministicMNManager>(chainstate, *node.connman, *node.evodb);
    src/test/util/setup_common.cpp:    node.dmnman = ::deterministicMNManager.get();
    src/test/util/setup_common.cpp:    ::deterministicMNManager.reset();
    src/test/util/setup_common.cpp:    ::sporkManager = std::make_unique<CSporkManager>();
    src/test/util/setup_common.cpp:    m_node.sporkman = ::sporkManager.get();
    src/test/util/setup_common.cpp:    ::governance = std::make_unique<CGovernanceManager>();
    src/test/util/setup_common.cpp:    m_node.govman = ::governance.get();
    src/test/util/setup_common.cpp:    ::dstxManager = std::make_unique<CDSTXManager>();
    src/test/util/setup_common.cpp:    m_node.dstxman = ::dstxManager.get();
    src/test/util/setup_common.cpp:    ::mmetaman = std::make_unique<CMasternodeMetaMan>(/* load_cache */ false);
    src/test/util/setup_common.cpp:    m_node.mn_metaman = ::mmetaman.get();
    src/test/util/setup_common.cpp:    ::netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(/* load_cache */ false);
    src/test/util/setup_common.cpp:    m_node.netfulfilledman = ::netfulfilledman.get();
    src/test/util/setup_common.cpp:    ::netfulfilledman.reset();
    src/test/util/setup_common.cpp:    ::mmetaman.reset();
    src/test/util/setup_common.cpp:    ::dstxManager.reset();
    src/test/util/setup_common.cpp:    ::governance.reset();
    src/test/util/setup_common.cpp:    ::sporkManager.reset();
    src/test/util/setup_common.cpp:    m_node.chainman->InitializeChainstate(m_node.mempool.get(), *m_node.mnhf_manager, *m_node.evodb, llmq::chainLocksHandler, llmq::quorumInstantSendManager, llmq::quorumBlockProcessor);
    ```

  ## Breaking Changes
  None, changes are limited to refactoring and do not logically change behaviour.

  ## Checklist:
  - [x] I have performed a self-review of my own code
  - [x] I have commented my code, particularly in hard-to-understand areas
  - [x] I have added or updated relevant unit/integration/functional/e2e tests
  - [x] I have made corresponding changes to the documentation **(note: N/A)**
  - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_

Top commit has no ACKs.

Tree-SHA512: f6d1a668728525e7cab7af200858a6ab6e20a24786d691630530a9019e8d2b4f474ed4358f40b76266b938dfe96420e0c64ee66a1a0986a3d3f254670162bb1c

Author: PastaPastaPasta

src/bench/rpc_blockchain.cpp

@@ -7,6 +7,7 @@
 
 #include <consensus/validation.h>
 #include <llmq/chainlocks.h>
+#include <llmq/context.h>
 #include <llmq/instantsend.h>
 #include <rpc/blockchain.h>
 #include <streams.h>
@@ -42,8 +43,9 @@ struct TestBlockAndIndex {
 static void BlockToJsonVerbose(benchmark::Bench& bench)
 {
     TestBlockAndIndex data;
+    const LLMQContext& llmq_ctx = *data.test_setup.m_node.llmq_ctx;
     bench.run([&] {
-        auto univalue = blockToJSON(data.block, &data.blockindex, &data.blockindex, *llmq::chainLocksHandler, *llmq::quorumInstantSendManager, /*verbose*/ true);
+        auto univalue = blockToJSON(data.block, &data.blockindex, &data.blockindex, *llmq_ctx.clhandler, *llmq_ctx.isman, /*verbose*/ true);
         ankerl::nanobench::doNotOptimizeAway(univalue);
     });
 }
@@ -53,7 +55,8 @@ BENCHMARK(BlockToJsonVerbose);
 static void BlockToJsonVerboseWrite(benchmark::Bench& bench)
 {
     TestBlockAndIndex data;
-    auto univalue = blockToJSON(data.block, &data.blockindex, &data.blockindex, *llmq::chainLocksHandler, *llmq::quorumInstantSendManager, /*verbose*/ true);
+    const LLMQContext& llmq_ctx = *data.test_setup.m_node.llmq_ctx;
+    auto univalue = blockToJSON(data.block, &data.blockindex, &data.blockindex, *llmq_ctx.clhandler, *llmq_ctx.isman, /*verbose*/ true);
     bench.run([&] {
         auto str = univalue.write();
         ankerl::nanobench::doNotOptimizeAway(str);

src/governance/vote.h

@@ -16,7 +16,7 @@ class CKey;
 class CKeyID;
 
 // INTENTION OF MASTERNODES REGARDING ITEM
-enum vote_outcome_enum_t {
+enum vote_outcome_enum_t : uint8_t {
     VOTE_OUTCOME_NONE      = 0,
     VOTE_OUTCOME_YES       = 1,
     VOTE_OUTCOME_NO        = 2,
@@ -25,7 +25,7 @@ enum vote_outcome_enum_t {
 
 
 // SIGNAL VARIOUS THINGS TO HAPPEN:
-enum vote_signal_enum_t {
+enum vote_signal_enum_t : uint8_t {
     VOTE_SIGNAL_NONE       = 0,
     VOTE_SIGNAL_FUNDING    = 1, //   -- fund this object for it's stated amount
     VOTE_SIGNAL_VALID      = 2, //   -- this object checks out in sentinel engine

src/init.cpp

@@ -304,12 +304,18 @@ void PrepareShutdown(NodeContext& node)
 
     // After all scheduled tasks have been flushed, destroy pointers
     // and reset all to nullptr.
-    ::governance.reset();
-    ::sporkManager.reset();
-    ::masternodeSync.reset();
+    node.netfulfilledman = nullptr;
     ::netfulfilledman.reset();
+    node.mn_metaman = nullptr;
     ::mmetaman.reset();
+    node.dstxman = nullptr;
     ::dstxManager.reset();
+    node.mn_sync = nullptr;
+    ::masternodeSync.reset();
+    node.sporkman = nullptr;
+    ::sporkManager.reset();
+    node.govman = nullptr;
+    ::governance.reset();
 
     // Stop and delete all indexes only after flushing background callbacks.
     if (g_txindex) {
@@ -342,9 +348,10 @@ void PrepareShutdown(NodeContext& node)
             node.llmq_ctx.reset();
         }
         llmq::quorumSnapshotManager.reset();
+        node.dmnman = nullptr;
         deterministicMNManager.reset();
+        node.cpoolman = nullptr;
         creditPoolManager.reset();
-        node.creditPoolManager = nullptr;
         node.mnhf_manager.reset();
         node.evodb.reset();
     }
@@ -1705,15 +1712,17 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     assert(!::governance);
     ::governance = std::make_unique<CGovernanceManager>();
+    node.govman = ::governance.get();
 
     assert(!node.peerman);
     node.peerman = PeerManager::make(chainparams, *node.connman, *node.addrman, node.banman.get(),
-                                     *node.scheduler, chainman, *node.mempool, *::governance,
+                                     *node.scheduler, chainman, *node.mempool, *node.govman,
                                      node.cj_ctx, node.llmq_ctx, ignores_incoming_txs);
     RegisterValidationInterface(node.peerman.get());
 
     assert(!::sporkManager);
     ::sporkManager = std::make_unique<CSporkManager>();
+    node.sporkman = ::sporkManager.get();
 
     std::vector<std::string> vSporkAddresses;
     if (args.IsArgSet("-sporkaddr")) {
@@ -1722,24 +1731,26 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
         vSporkAddresses = Params().SporkAddresses();
     }
     for (const auto& address: vSporkAddresses) {
-        if (!::sporkManager->SetSporkAddress(address)) {
+        if (!node.sporkman->SetSporkAddress(address)) {
             return InitError(_("Invalid spork address specified with -sporkaddr"));
         }
     }
 
     int minsporkkeys = args.GetArg("-minsporkkeys", Params().MinSporkKeys());
-    if (!::sporkManager->SetMinSporkKeys(minsporkkeys)) {
+    if (!node.sporkman->SetMinSporkKeys(minsporkkeys)) {
         return InitError(_("Invalid minimum number of spork signers specified with -minsporkkeys"));
     }
 
 
     if (args.IsArgSet("-sporkkey")) { // spork priv key
-        if (!::sporkManager->SetPrivKey(args.GetArg("-sporkkey", ""))) {
+        if (!node.sporkman->SetPrivKey(args.GetArg("-sporkkey", ""))) {
             return InitError(_("Unable to sign spork message, wrong key?"));
         }
     }
 
-    ::masternodeSync = std::make_unique<CMasternodeSync>(*node.connman, *::governance);
+    assert(!::masternodeSync);
+    ::masternodeSync = std::make_unique<CMasternodeSync>(*node.connman, *node.govman);
+    node.mn_sync = ::masternodeSync.get();
 
     // sanitize comments per BIP-0014, format user agent and check total size
     std::vector<std::string> uacomments;
@@ -1861,10 +1872,8 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     }
 #endif
 
-    assert(::governance != nullptr);
-    assert(::masternodeSync != nullptr);
     pdsNotificationInterface = new CDSNotificationInterface(
-        *node.connman, *::masternodeSync, ::deterministicMNManager, *::governance, node.llmq_ctx, node.cj_ctx
+        *node.connman, *node.mn_sync, ::deterministicMNManager, *node.govman, node.llmq_ctx, node.cj_ctx
     );
     RegisterValidationInterface(pdsNotificationInterface);
 
@@ -1876,7 +1885,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     // ********************************************************* Step 7a: Load sporks
 
-    if (!::sporkManager->LoadCache()) {
+    if (!node.sporkman->LoadCache()) {
         auto file_path = (GetDataDir() / "sporks.dat").string();
         return InitError(strprintf(_("Failed to load sporks cache from %s"), file_path));
     }
@@ -1956,10 +1965,11 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
                 // Same logic as above with pblocktree
                 deterministicMNManager.reset();
-                deterministicMNManager.reset(new CDeterministicMNManager(chainman.ActiveChainstate(), *node.connman, *node.evodb));
+                deterministicMNManager = std::make_unique<CDeterministicMNManager>(chainman.ActiveChainstate(), *node.connman, *node.evodb);
+                node.dmnman = deterministicMNManager.get();
                 creditPoolManager.reset();
                 creditPoolManager = std::make_unique<CCreditPoolManager>(*node.evodb);
-                node.creditPoolManager = creditPoolManager.get();
+                node.cpoolman = creditPoolManager.get();
                 llmq::quorumSnapshotManager.reset();
                 llmq::quorumSnapshotManager.reset(new llmq::CQuorumSnapshotManager(*node.evodb));
 
@@ -1968,7 +1978,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
                     node.llmq_ctx->Stop();
                 }
                 node.llmq_ctx.reset();
-                node.llmq_ctx.reset(new LLMQContext(chainman.ActiveChainstate(), *node.connman, *node.evodb, *::sporkManager, *node.mempool, node.peerman, false, fReset || fReindexChainState));
+                node.llmq_ctx.reset(new LLMQContext(chainman.ActiveChainstate(), *node.connman, *node.evodb, *node.sporkman, *node.mempool, node.peerman, false, fReset || fReindexChainState));
                 // Have to start it early to let VerifyDB check ChainLock signatures in coinbase
                 node.llmq_ctx->Start();
 
@@ -2101,11 +2111,11 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
                     break; // out of the chainstate activation do-while
                 }
 
-                if (!deterministicMNManager->MigrateDBIfNeeded()) {
+                if (!node.dmnman->MigrateDBIfNeeded()) {
                     strLoadError = _("Error upgrading evo database");
                     break;
                 }
-                if (!deterministicMNManager->MigrateDBIfNeeded2()) {
+                if (!node.dmnman->MigrateDBIfNeeded2()) {
                     strLoadError = _("Error upgrading evo database");
                     break;
                 }
@@ -2209,7 +2219,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     // ********************************************************* Step 7c: Setup CoinJoin
 
-    node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.mempool, *::masternodeSync, !ignores_incoming_txs);
+    node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.mempool, *node.mn_sync, !ignores_incoming_txs);
 
 #ifdef ENABLE_WALLET
     node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*node.cj_ctx->walletman);
@@ -2221,7 +2231,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     bool fLoadCacheFiles = !(fReindex || fReindexChainState) && (::ChainActive().Tip() != nullptr);
 
     if (!fDisableGovernance) {
-        if (!::governance->LoadCache(fLoadCacheFiles)) {
+        if (!node.govman->LoadCache(fLoadCacheFiles)) {
             auto file_path = (GetDataDir() / "governance.dat").string();
             if (fLoadCacheFiles && !fDisableGovernance) {
                 return InitError(strprintf(_("Failed to load governance cache from %s"), file_path));
@@ -2232,10 +2242,12 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     assert(!::dstxManager);
     ::dstxManager = std::make_unique<CDSTXManager>();
+    node.dstxman = ::dstxManager.get();
 
     assert(!::mmetaman);
     ::mmetaman = std::make_unique<CMasternodeMetaMan>(fLoadCacheFiles);
-    if (!::mmetaman->IsValid()) {
+    node.mn_metaman = ::mmetaman.get();
+    if (!node.mn_metaman->IsValid()) {
         auto file_path = (GetDataDir() / "mncache.dat").string();
         if (fLoadCacheFiles) {
             return InitError(strprintf(_("Failed to load masternode cache from %s"), file_path));
@@ -2245,7 +2257,8 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     assert(!::netfulfilledman);
     ::netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(fLoadCacheFiles);
-    if (!::netfulfilledman->IsValid()) {
+    node.netfulfilledman = ::netfulfilledman.get();
+    if (!node.netfulfilledman->IsValid()) {
         auto file_path = (GetDataDir() / "netfulfilled.dat").string();
         if (fLoadCacheFiles) {
             return InitError(strprintf(_("Failed to load fulfilled requests cache from %s"), file_path));
@@ -2316,13 +2329,13 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     // ********************************************************* Step 10a: schedule Dash-specific tasks
 
-    node.scheduler->scheduleEvery(std::bind(&CNetFulfilledRequestManager::DoMaintenance, std::ref(*netfulfilledman)), std::chrono::minutes{1});
-    node.scheduler->scheduleEvery(std::bind(&CMasternodeSync::DoMaintenance, std::ref(*::masternodeSync)), std::chrono::seconds{1});
-    node.scheduler->scheduleEvery(std::bind(&CMasternodeUtils::DoMaintenance, std::ref(*node.connman), std::ref(*::masternodeSync), std::ref(*node.cj_ctx)), std::chrono::minutes{1});
-    node.scheduler->scheduleEvery(std::bind(&CDeterministicMNManager::DoMaintenance, std::ref(*deterministicMNManager)), std::chrono::seconds{10});
+    node.scheduler->scheduleEvery(std::bind(&CNetFulfilledRequestManager::DoMaintenance, std::ref(*node.netfulfilledman)), std::chrono::minutes{1});
+    node.scheduler->scheduleEvery(std::bind(&CMasternodeSync::DoMaintenance, std::ref(*node.mn_sync)), std::chrono::seconds{1});
+    node.scheduler->scheduleEvery(std::bind(&CMasternodeUtils::DoMaintenance, std::ref(*node.connman), std::ref(*node.mn_sync), std::ref(*node.cj_ctx)), std::chrono::minutes{1});
+    node.scheduler->scheduleEvery(std::bind(&CDeterministicMNManager::DoMaintenance, std::ref(*node.dmnman)), std::chrono::seconds{10});
 
     if (!fDisableGovernance) {
-        node.scheduler->scheduleEvery(std::bind(&CGovernanceManager::DoMaintenance, std::ref(*::governance), std::ref(*node.connman)), std::chrono::minutes{5});
+        node.scheduler->scheduleEvery(std::bind(&CGovernanceManager::DoMaintenance, std::ref(*node.govman), std::ref(*node.connman)), std::chrono::minutes{5});
     }
 
     if (fMasternodeMode) {

src/interfaces/node.h

@@ -37,6 +37,8 @@ enum class SynchronizationState;
 struct CNodeStateStats;
 struct NodeContext;
 
+enum vote_signal_enum_t : uint8_t;
+
 namespace interfaces {
 class Handler;
 class WalletLoader;
@@ -51,6 +53,7 @@ class EVO
 public:
     virtual ~EVO() {}
     virtual std::pair<CDeterministicMNList, const CBlockIndex*> getListAtChainTip() = 0;
+    virtual void setContext(NodeContext* context) {}
 };
 
 //! Interface for the src/governance part of a dash node (dashd process).
@@ -59,6 +62,9 @@ class GOV
 public:
     virtual ~GOV() {}
     virtual void getAllNewerThan(std::vector<CGovernanceObject> &objs, int64_t nMoreThanTime) = 0;
+    virtual int32_t getObjAbsYesCount(const CGovernanceObject& obj, vote_signal_enum_t vote_signal) = 0;
+    virtual bool getObjLocalValidity(const CGovernanceObject& obj, std::string& error, bool check_collateral) = 0;
+    virtual void setContext(NodeContext* context) {}
 };
 
 //! Interface for the src/llmq part of a dash node (dashd process).
@@ -67,6 +73,7 @@ class LLMQ
 public:
     virtual ~LLMQ() {}
     virtual size_t getInstantSentLockCount() = 0;
+    virtual void setContext(NodeContext* context) {}
 };
 
 //! Interface for the src/masternode part of a dash node (dashd process).
@@ -79,6 +86,7 @@ class Sync
     virtual bool isBlockchainSynced() = 0;
     virtual bool isSynced() = 0;
     virtual std::string getSyncStatus() =  0;
+    virtual void setContext(NodeContext* context) {}
 };
 }
 

src/node/context.h

@@ -16,9 +16,16 @@ class CAddrMan;
 class CBlockPolicyEstimator;
 class CConnman;
 class CCreditPoolManager;
+class CDeterministicMNManager;
 class ChainstateManager;
+class CDSTXManager;
 class CEvoDB;
+class CGovernanceManager;
+class CMasternodeMetaMan;
+class CMasternodeSync;
+class CNetFulfilledRequestManager;
 class CScheduler;
+class CSporkManager;
 class CTxMemPool;
 class CMNHFManager;
 class PeerManager;
@@ -63,12 +70,18 @@ struct NodeContext {
     std::unique_ptr<CScheduler> scheduler;
     std::function<void()> rpc_interruption_point = [] {};
     //! Dash
-    std::unique_ptr<LLMQContext> llmq_ctx;
-    CCreditPoolManager* creditPoolManager;
-    std::unique_ptr<CMNHFManager> mnhf_manager;
-    std::unique_ptr<CJContext> cj_ctx;
-
     std::unique_ptr<CEvoDB> evodb;
+    std::unique_ptr<CJContext> cj_ctx;
+    std::unique_ptr<CMNHFManager> mnhf_manager;
+    std::unique_ptr<LLMQContext> llmq_ctx;
+    CCreditPoolManager* cpoolman{nullptr};
+    CDeterministicMNManager* dmnman{nullptr};
+    CDSTXManager* dstxman{nullptr};
+    CGovernanceManager* govman{nullptr};
+    CMasternodeMetaMan* mn_metaman{nullptr};
+    CMasternodeSync* mn_sync{nullptr};
+    CNetFulfilledRequestManager* netfulfilledman{nullptr};
+    CSporkManager* sporkman{nullptr};
 
     //! Declare default constructor and destructor that are not inline, so code
     //! instantiating the NodeContext struct doesn't need to #include class