From 15ee06f5eb49170ed1a19ac76b0abb3fc73af06e Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 8 Jun 2022 14:23:09 +0200
Subject: [PATCH 1/3] Introduce RPCContext instance.

This introduces the RPCContext class, and an associated global instance
(accessible through RPCContext::Get).  This class is empty for now, but
will in the future hold contextual information such as references to the
global chainstate, masternode module and others, for use by RPC method
handlers while the RPC server is running.

It will be difficult to explicitly pass references like these to the
RPC handlers, as that would require updating the entire RPC server
infrastructure and all RPC handler methods at once.  With this class, we
still lay the foundation for removing direct "global" accesses from
the RPC methods, and instead bundling them in the RPCContext class.  This
makes the use of global state from the RPC server clearer, and can be
used later on to fully remove any global access by simply providing the
RPCContext instance explicitly to handlers somehow.
---
 divi/src/Makefile.am    |  2 ++
 divi/src/RPCContext.cpp |  5 +++++
 divi/src/RPCContext.h   | 28 +++++++++++++++++++++++++++
 divi/src/rpcserver.cpp  | 43 +++++++++++++++++++++++++++++------------
 4 files changed, 66 insertions(+), 12 deletions(-)
 create mode 100644 divi/src/RPCContext.cpp
 create mode 100644 divi/src/RPCContext.h

diff --git a/divi/src/Makefile.am b/divi/src/Makefile.am
index fd7bf78be..7e4f38c95 100644
--- a/divi/src/Makefile.am
+++ b/divi/src/Makefile.am
@@ -216,6 +216,7 @@ BITCOIN_CORE_H = \
   IndexDatabaseUpdateCollector.h \
   NodeState.h \
   NodeStateRegistry.h \
+  RPCContext.h \
   BlocksInFlightRegistry.h \
   NodeSignals.h \
   BlockRejects.h\
@@ -436,6 +437,7 @@ libbitcoin_server_a_SOURCES = \
   NodeState.cpp \
   BlocksInFlightRegistry.cpp \
   NodeStateRegistry.cpp \
+  RPCContext.cpp \
   BlockFileHelpers.cpp \
   main.cpp \
   TransactionSearchIndexes.cpp \
diff --git a/divi/src/RPCContext.cpp b/divi/src/RPCContext.cpp
new file mode 100644
index 000000000..b697f2d26
--- /dev/null
+++ b/divi/src/RPCContext.cpp
@@ -0,0 +1,5 @@
+#include "RPCContext.h"
+
+RPCContext::RPCContext () = default;
+
+RPCContext::~RPCContext () = default;
diff --git a/divi/src/RPCContext.h b/divi/src/RPCContext.h
new file mode 100644
index 000000000..27fe16f8c
--- /dev/null
+++ b/divi/src/RPCContext.h
@@ -0,0 +1,28 @@
+#ifndef RPC_CONTEXT_H
+#define RPC_CONTEXT_H
+
+/** This class holds all the "context" (such as the chainstate, masternode
+ *  and other references) needed to handle RPC method calls.  */
+class RPCContext
+{
+
+public:
+
+  /** Constructs a new instance based on globals.  */
+  RPCContext ();
+
+  RPCContext (const RPCContext&) = delete;
+  void operator= (const RPCContext&) = delete;
+
+  ~RPCContext ();
+
+  /** Returns the global instance that should be used during RPC calls
+   *  (called from the RPC method handler).
+   *
+   *  This method is implemented in rpcserver.cpp.
+   */
+  static RPCContext& Get ();
+
+};
+
+#endif // RPC_CONTEXT_H
diff --git a/divi/src/rpcserver.cpp b/divi/src/rpcserver.cpp
index 3f24f68a2..c80fd8fa6 100644
--- a/divi/src/rpcserver.cpp
+++ b/divi/src/rpcserver.cpp
@@ -17,6 +17,7 @@
 #ifdef ENABLE_WALLET
 #include "wallet.h"
 #endif
+#include "RPCContext.h"
 #include "Settings.h"
 #include <utilmoneystr.h>
 #include <random.h>
@@ -162,20 +163,30 @@ using namespace boost::asio;
 using namespace json_spirit;
 using namespace std;
 extern Settings& settings;
-static std::string strRPCUserColonPass;
 
-static bool fRPCRunning = false;
-static bool fRPCInWarmup = true;
-static std::string rpcWarmupStatus("RPC server started");
-static CCriticalSection cs_rpcWarmup;
+namespace
+{
+
+std::string strRPCUserColonPass;
+
+bool fRPCRunning = false;
+bool fRPCInWarmup = true;
+std::string rpcWarmupStatus("RPC server started");
+CCriticalSection cs_rpcWarmup;
 
 //! These are created by StartRPCThreads, destroyed in StopRPCThreads
-static asio::io_service* rpc_io_service = NULL;
-static map<string, boost::shared_ptr<deadline_timer> > deadlineTimers;
-static boost::thread_group* rpc_worker_group = NULL;
-static boost::asio::io_service::work* rpc_dummy_work = NULL;
-static std::vector<CSubNet> rpc_allow_subnets; //!< List of subnets to allow RPC connections from
-static std::vector<boost::shared_ptr<ip::tcp::acceptor> > rpc_acceptors;
+asio::io_service* rpc_io_service = NULL;
+std::map<std::string, boost::shared_ptr<deadline_timer> > deadlineTimers;
+boost::thread_group* rpc_worker_group = NULL;
+boost::asio::io_service::work* rpc_dummy_work = NULL;
+std::vector<CSubNet> rpc_allow_subnets; //!< List of subnets to allow RPC connections from
+std::vector<boost::shared_ptr<ip::tcp::acceptor> > rpc_acceptors;
+
+/** The global RPCContext instance.  It is created when the RPC server
+ *  has finished warmup, and destructed when the RPC threads are stopped.  */
+std::unique_ptr<RPCContext> rpcContext;
+
+} // anonymous namespace
 
 void RPCTypeCheck(const Array& params,
     const list<Value_type>& typesExpected,
@@ -787,6 +798,7 @@ void StopRPCThreads()
     rpc_worker_group = NULL;
     delete rpc_io_service;
     rpc_io_service = NULL;
+    rpcContext.reset();
 }
 
 bool IsRPCRunning()
@@ -804,6 +816,7 @@ void SetRPCWarmupFinished()
 {
     LOCK(cs_rpcWarmup);
     assert(fRPCInWarmup);
+    rpcContext.reset(new RPCContext());
     fRPCInWarmup = false;
 }
 
@@ -815,6 +828,12 @@ bool RPCIsInWarmup(std::string* outStatus)
     return fRPCInWarmup;
 }
 
+RPCContext& RPCContext::Get()
+{
+    assert(rpcContext != nullptr);
+    return *rpcContext;
+}
+
 void RPCRunHandler(const boost::system::error_code& err, boost::function<void(void)> func)
 {
     if (!err)
@@ -1233,4 +1252,4 @@ std::string HelpExampleRpc(string methodname, string args)
     return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
            "\"method\": \"" +
            methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:51473/\n";
-}
\ No newline at end of file
+}

From d3d7f53738f714a2611cb4c588c5d9a9fee0f3f8 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 8 Jun 2022 15:02:59 +0200
Subject: [PATCH 2/3] Add spork manager to RPCContext.

Add the global CSporkManager to RPCContext as the first actual data field.
With this, we can replace the use of GetSporkManager() from all RPC methods
with the RPCContext.
---
 divi/src/RPCContext.cpp    |  6 +++++-
 divi/src/RPCContext.h      | 12 ++++++++++++
 divi/src/rpcblockchain.cpp |  8 +++++---
 divi/src/rpclottery.cpp    |  7 ++++---
 divi/src/rpcmisc.cpp       |  4 +++-
 divi/src/rpcwallet.cpp     | 30 ++++++++++++++++++++----------
 6 files changed, 49 insertions(+), 18 deletions(-)

diff --git a/divi/src/RPCContext.cpp b/divi/src/RPCContext.cpp
index b697f2d26..940c6e01b 100644
--- a/divi/src/RPCContext.cpp
+++ b/divi/src/RPCContext.cpp
@@ -1,5 +1,9 @@
 #include "RPCContext.h"
 
-RPCContext::RPCContext () = default;
+#include "spork.h"
+
+RPCContext::RPCContext ()
+  : sporkManager(GetSporkManager ())
+{}
 
 RPCContext::~RPCContext () = default;
diff --git a/divi/src/RPCContext.h b/divi/src/RPCContext.h
index 27fe16f8c..eb2ec9380 100644
--- a/divi/src/RPCContext.h
+++ b/divi/src/RPCContext.h
@@ -1,11 +1,17 @@
 #ifndef RPC_CONTEXT_H
 #define RPC_CONTEXT_H
 
+class CSporkManager;
+
 /** This class holds all the "context" (such as the chainstate, masternode
  *  and other references) needed to handle RPC method calls.  */
 class RPCContext
 {
 
+private:
+
+  CSporkManager& sporkManager;
+
 public:
 
   /** Constructs a new instance based on globals.  */
@@ -23,6 +29,12 @@ class RPCContext
    */
   static RPCContext& Get ();
 
+  CSporkManager&
+  SporkManager ()
+  {
+    return sporkManager;
+  }
+
 };
 
 #endif // RPC_CONTEXT_H
diff --git a/divi/src/rpcblockchain.cpp b/divi/src/rpcblockchain.cpp
index 8590c4f9a..b3a498607 100644
--- a/divi/src/rpcblockchain.cpp
+++ b/divi/src/rpcblockchain.cpp
@@ -6,6 +6,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <ChainstateManager.h>
+#include <RPCContext.h>
 #include "checkpoints.h"
 #include "main.h"
 #include "BlockDiskAccessor.h"
@@ -27,7 +28,6 @@
 #include <JsonTxHelpers.h>
 #include <init.h>
 #include <JsonBlockHelpers.h>
-#include <spork.h>
 
 using namespace json_spirit;
 using namespace std;
@@ -628,6 +628,7 @@ Value invalidateblock(const Array& params, bool fHelp, CWallet* pwallet)
     uint256 hash(strHash);
     CValidationState state;
 
+    auto& ctx = RPCContext::Get();
     ChainstateManager::Reference chainstate;
     auto& blockMap = chainstate->GetBlockMap();
     const auto mit = blockMap.find(hash);
@@ -638,7 +639,7 @@ Value invalidateblock(const Array& params, bool fHelp, CWallet* pwallet)
     InvalidateBlock(*chainstate, state, pblockindex);
 
     if (state.IsValid()) {
-        ActivateBestChain(*chainstate, GetSporkManager(), state);
+        ActivateBestChain(*chainstate, ctx.SporkManager(), state);
     }
 
     if (!state.IsValid()) {
@@ -665,6 +666,7 @@ Value reconsiderblock(const Array& params, bool fHelp, CWallet* pwallet)
     uint256 hash(strHash);
     CValidationState state;
 
+    auto& ctx = RPCContext::Get();
     ChainstateManager::Reference chainstate;
     auto& blockMap = chainstate->GetBlockMap();
     const auto mit = blockMap.find(hash);
@@ -675,7 +677,7 @@ Value reconsiderblock(const Array& params, bool fHelp, CWallet* pwallet)
     ReconsiderBlock(*chainstate, state, pblockindex);
 
     if (state.IsValid()) {
-        ActivateBestChain(*chainstate, GetSporkManager(), state);
+        ActivateBestChain(*chainstate, ctx.SporkManager(), state);
     }
 
     if (!state.IsValid()) {
diff --git a/divi/src/rpclottery.cpp b/divi/src/rpclottery.cpp
index 7d5e414f2..d56e85be5 100644
--- a/divi/src/rpclottery.cpp
+++ b/divi/src/rpclottery.cpp
@@ -1,7 +1,7 @@
 #include <chain.h>
 #include <ChainstateManager.h>
-#include <spork.h>
 #include <LotteryWinnersCalculator.h>
+#include <RPCContext.h>
 #include <SuperblockSubsidyContainer.h>
 #include <script/standard.h>
 #include <json/json_spirit_value.h>
@@ -40,11 +40,12 @@ Value getlotteryblockwinners(const Array& params, bool fHelp, CWallet* pwallet)
 
 
 
+    auto& ctx = RPCContext::Get();
     const auto& chainParameters = Params();
-    const SuperblockSubsidyContainer subsidyCointainer(chainParameters, GetSporkManager());
+    const SuperblockSubsidyContainer subsidyCointainer(chainParameters, ctx.SporkManager());
     const ChainstateManager::Reference chainstate;
     const LotteryWinnersCalculator calculator(
-        chainParameters.GetLotteryBlockStartBlock(), chainstate->ActiveChain(), GetSporkManager(),subsidyCointainer.superblockHeightValidator());
+        chainParameters.GetLotteryBlockStartBlock(), chainstate->ActiveChain(), ctx.SporkManager(),subsidyCointainer.superblockHeightValidator());
     const CBlockIndex* chainTip = chainstate->ActiveChain().Tip();
     if(!chainTip) throw JSONRPCError(RPC_MISC_ERROR,"Could not acquire lock on chain tip.");
     int blockHeight = (params.size()>0)? std::min(params[0].get_int(),chainTip->nHeight): chainTip->nHeight;
diff --git a/divi/src/rpcmisc.cpp b/divi/src/rpcmisc.cpp
index 5aec0b261..e8f8f8496 100644
--- a/divi/src/rpcmisc.cpp
+++ b/divi/src/rpcmisc.cpp
@@ -8,6 +8,7 @@
 #include "base58.h"
 #include "clientversion.h"
 #include "init.h"
+#include <RPCContext.h>
 #include <rpcprotocol.h>
 #include "rpcserver.h"
 #include "spork.h"
@@ -278,7 +279,8 @@ class DescribeAddressVisitor : public boost::static_visitor<Object>
 */
 Value spork(const Array& params, bool fHelp, CWallet* pwallet)
 {
-    CSporkManager& sporkManager = GetSporkManager();
+    auto& ctx = RPCContext::Get();
+    CSporkManager& sporkManager = ctx.SporkManager();
     if (params.size() == 1 && params[0].get_str() == "show") {
         Object ret;
         for (int nSporkID = SPORK_START; nSporkID <= SPORK_END; nSporkID++) {
diff --git a/divi/src/rpcwallet.cpp b/divi/src/rpcwallet.cpp
index fbbec527e..25fa65e8d 100644
--- a/divi/src/rpcwallet.cpp
+++ b/divi/src/rpcwallet.cpp
@@ -10,6 +10,7 @@
 #include "core_io.h"
 #include <chain.h>
 #include <ChainstateManager.h>
+#include <RPCContext.h>
 #include "init.h"
 #include <rpcprotocol.h>
 #include "rpcserver.h"
@@ -37,7 +38,6 @@
 
 #include "json/json_spirit_utils.h"
 #include "json/json_spirit_value.h"
-#include "spork.h"
 #include <boost/assign/list_of.hpp>
 #include <blockmap.h>
 #include <BlockDiskAccessor.h>
@@ -1795,14 +1795,17 @@ Value listreceivedbyaccount(const Array& params, bool fHelp, CWallet* pwallet)
     return ListReceived(pwallet, params, true);
 }
 
-static void MaybePushAddress(Object& entry, const CTxDestination& dest)
+namespace
+{
+
+void MaybePushAddress(Object& entry, const CTxDestination& dest)
 {
     CBitcoinAddress addr;
     if (addr.Set(dest))
         entry.push_back(Pair("address", addr.ToString()));
 }
 
-static std::string GetAccountAddressName(const CWallet& wallet, const CTxDestination &dest)
+std::string GetAccountAddressName(const CWallet& wallet, const CTxDestination &dest)
 {
     const AddressBook& addressBook = wallet.getAddressBookManager().getAddressBook();
     AddressBook::const_iterator mi = addressBook.find(dest);
@@ -1814,7 +1817,7 @@ static std::string GetAccountAddressName(const CWallet& wallet, const CTxDestina
     return std::string();
 }
 
-static int ComputeBlockHeightOfFirstConfirmation(const uint256 blockHash)
+int ComputeBlockHeightOfFirstConfirmation(const uint256 blockHash)
 {
     LOCK(cs_main);
     const ChainstateManager::Reference chainstate;
@@ -1823,7 +1826,7 @@ static int ComputeBlockHeightOfFirstConfirmation(const uint256 blockHash)
     return (it==blockMap.end() || it->second==nullptr)? 0 : it->second->nHeight;
 }
 
-static std::string ParseScriptAsAddressString(const CScript& scriptPubKey)
+std::string ParseScriptAsAddressString(const CScript& scriptPubKey)
 {
     CTxDestination parsedAddress;
     if(ExtractDestination(scriptPubKey, parsedAddress))
@@ -1839,9 +1842,9 @@ static std::string ParseScriptAsAddressString(const CScript& scriptPubKey)
         return "Unknown address";
     }
 }
-void ParseTransactionDetails(const CWallet& wallet, const CWalletTx& wtx, const string& strAccount, int nMinDepth, bool fLong, Array& ret, const UtxoOwnershipFilter& filter)
+void ParseTransactionDetails(RPCContext& ctx, const CWallet& wallet, const CWalletTx& wtx, const string& strAccount, int nMinDepth, bool fLong, Array& ret, const UtxoOwnershipFilter& filter)
 {
-    const SuperblockSubsidyContainer superblockSubsidies(Params(), GetSporkManager());
+    const SuperblockSubsidyContainer superblockSubsidies(Params(), ctx.SporkManager());
     const I_SuperblockHeightValidator& heightValidator = superblockSubsidies.superblockHeightValidator();
     const I_BlockSubsidyProvider& blockSubsidies = superblockSubsidies.blockSubsidiesProvider();
 
@@ -2030,6 +2033,8 @@ void ParseTransactionDetails(const CWallet& wallet, const CWalletTx& wtx, const
     }
 }
 
+} // anonymous namespace
+
 Value listtransactions(const Array& params, bool fHelp, CWallet* pwallet)
 {
     if (fHelp || params.size() > 4)
@@ -2106,6 +2111,8 @@ Value listtransactions(const Array& params, bool fHelp, CWallet* pwallet)
     if (nFrom < 0)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");
 
+    auto& ctx = RPCContext::Get();
+
     Array ret;
 
     CWallet::TxItems txOrdered = pwallet->OrderedTxItems();
@@ -2113,7 +2120,7 @@ Value listtransactions(const Array& params, bool fHelp, CWallet* pwallet)
     // iterate backwards until we have nCount items to return:
     for (CWallet::TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
         const CWalletTx* const pwtx = (*it).second;
-        ParseTransactionDetails(*pwallet, *pwtx, strAccount, 0, true, ret, filter);
+        ParseTransactionDetails(ctx, *pwallet, *pwtx, strAccount, 0, true, ret, filter);
         if ((int)ret.size() >= (nCount + nFrom)) break;
     }
     // ret is newest to oldest
@@ -2247,6 +2254,7 @@ Value listsinceblock(const Array& params, bool fHelp, CWallet* pwallet)
     UtxoOwnershipFilter filter;
     filter.addOwnershipType(isminetype::ISMINE_SPENDABLE);
 
+    auto& ctx = RPCContext::Get();
     const ChainstateManager::Reference chainstate;
     const auto& chain = chainstate->ActiveChain();
     const auto& blockMap = chainstate->GetBlockMap();
@@ -2280,7 +2288,7 @@ Value listsinceblock(const Array& params, bool fHelp, CWallet* pwallet)
         CWalletTx tx = *(*it);
 
         if (depth == -1 || pwallet->getConfirmationCalculator().GetNumberOfBlockConfirmations(tx) < depth)
-            ParseTransactionDetails(*pwallet, tx, "*", 0, true, transactions, filter);
+            ParseTransactionDetails(ctx, *pwallet, tx, "*", 0, true, transactions, filter);
     }
 
     const CBlockIndex* pblockLast = chain[chain.Height() + 1 - target_confirms];
@@ -2339,6 +2347,8 @@ Value gettransaction(const Array& params, bool fHelp, CWallet* pwallet)
         if (params[1].get_bool())
             filter.addOwnershipType(isminetype::ISMINE_WATCH_ONLY);
 
+    auto& ctx = RPCContext::Get();
+
     Object entry;
     const CWalletTx* txPtr = pwallet->GetWalletTx(hash);
     if (txPtr == nullptr)
@@ -2356,7 +2366,7 @@ Value gettransaction(const Array& params, bool fHelp, CWallet* pwallet)
     WalletTxToJSON(*pwallet,wtx, entry);
 
     Array details;
-    ParseTransactionDetails(*pwallet, wtx, "*", 0, false, details, filter);
+    ParseTransactionDetails(ctx, *pwallet, wtx, "*", 0, false, details, filter);
     entry.push_back(Pair("details", details));
 
     string strHex = EncodeHexTx(static_cast<CTransaction>(wtx));

From 8c0b78f7f441539c25395b201024d49bf762ac49 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 15 Jun 2022 16:50:13 +0200
Subject: [PATCH 3/3] Add MasternodeModule to RPCContext.

This adds a reference to the global MasternodeModule to the RPCContext
class, and accesses it through this instead of GetMasternodeModule
throughout all RPC code.
---
 divi/src/RPCContext.cpp            |  3 ++-
 divi/src/RPCContext.h              |  8 ++++++
 divi/src/RpcMasternodeFeatures.cpp | 39 +++++++++++++++---------------
 divi/src/RpcMasternodeFeatures.h   | 11 +++++----
 divi/src/rpcmasternode.cpp         | 32 ++++++++++++++++++------
 divi/src/rpcmisc.cpp               |  7 ++++--
 6 files changed, 65 insertions(+), 35 deletions(-)

diff --git a/divi/src/RPCContext.cpp b/divi/src/RPCContext.cpp
index 940c6e01b..f5ea35be0 100644
--- a/divi/src/RPCContext.cpp
+++ b/divi/src/RPCContext.cpp
@@ -1,9 +1,10 @@
 #include "RPCContext.h"
 
 #include "spork.h"
+#include "MasternodeModule.h"
 
 RPCContext::RPCContext ()
-  : sporkManager(GetSporkManager ())
+  : sporkManager(GetSporkManager ()), masternodeModule(GetMasternodeModule ())
 {}
 
 RPCContext::~RPCContext () = default;
diff --git a/divi/src/RPCContext.h b/divi/src/RPCContext.h
index eb2ec9380..e4cacb551 100644
--- a/divi/src/RPCContext.h
+++ b/divi/src/RPCContext.h
@@ -2,6 +2,7 @@
 #define RPC_CONTEXT_H
 
 class CSporkManager;
+class MasternodeModule;
 
 /** This class holds all the "context" (such as the chainstate, masternode
  *  and other references) needed to handle RPC method calls.  */
@@ -11,6 +12,7 @@ class RPCContext
 private:
 
   CSporkManager& sporkManager;
+  const ::MasternodeModule& masternodeModule;
 
 public:
 
@@ -35,6 +37,12 @@ class RPCContext
     return sporkManager;
   }
 
+  const ::MasternodeModule&
+  MasternodeModule () const
+  {
+    return masternodeModule;
+  }
+
 };
 
 #endif // RPC_CONTEXT_H
diff --git a/divi/src/RpcMasternodeFeatures.cpp b/divi/src/RpcMasternodeFeatures.cpp
index 00eaa06c3..2f53c86cf 100644
--- a/divi/src/RpcMasternodeFeatures.cpp
+++ b/divi/src/RpcMasternodeFeatures.cpp
@@ -2,6 +2,7 @@
 
 #include <base58address.h>
 #include <MasternodeModule.h>
+#include <RPCContext.h>
 #include <masternode.h>
 #include <keystore.h>
 #include <streams.h>
@@ -78,9 +79,9 @@ namespace
 
 /** Relays an already parsed masternode broadcast, optionally updating the
  *  contained ping if we can (because it is our masternode).  */
-MasternodeStartResult RelayParsedMasternodeBroadcast(CMasternodeBroadcast mnb, const bool updatePing)
+MasternodeStartResult RelayParsedMasternodeBroadcast(const RPCContext& ctx, CMasternodeBroadcast mnb, const bool updatePing)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
     auto& activeMasternode = mnModule.getActiveMasternode();
     auto& mnodeman = mnModule.getMasternodeManager();
 
@@ -146,18 +147,18 @@ bool SignMasternodeBroadcast(const CKeyStore& keystore, std::string& hexData)
     return true;
 }
 
-MasternodeStartResult RelayMasternodeBroadcast(const std::string& hexData, const std::string& signature, const bool updatePing)
+MasternodeStartResult RelayMasternodeBroadcast(const RPCContext& ctx, const std::string& hexData, const std::string& signature, const bool updatePing)
 {
     CMasternodeBroadcast mnb = readFromHex<CMasternodeBroadcast>(hexData);
     if(!signature.empty())
         mnb.signature = ParseHex(signature);
 
-    return RelayParsedMasternodeBroadcast(mnb, updatePing);
+    return RelayParsedMasternodeBroadcast(ctx, mnb, updatePing);
 }
 
-MasternodeStartResult StartMasternode(const CKeyStore& keyStore, const StoredMasternodeBroadcasts& stored, std::string alias, bool deferRelay)
+MasternodeStartResult StartMasternode(const RPCContext& ctx, const CKeyStore& keyStore, const StoredMasternodeBroadcasts& stored, std::string alias, bool deferRelay)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
 
     MasternodeStartResult result;
     for(const auto& configEntry : mnModule.getMasternodeConfigurations().getEntries())
@@ -206,16 +207,16 @@ MasternodeStartResult StartMasternode(const CKeyStore& keyStore, const StoredMas
             return result;
         }
 
-        return RelayParsedMasternodeBroadcast (mnb, updatePing);
+        return RelayParsedMasternodeBroadcast (ctx, mnb, updatePing);
     }
     result.status = false;
     result.errorMessage = "Invalid alias, couldn't find MN. Check your masternode.conf file";
     return result;
 }
 
-ActiveMasternodeStatus GetActiveMasternodeStatus()
+ActiveMasternodeStatus GetActiveMasternodeStatus(const RPCContext& ctx)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
     if (!mnModule.localNodeIsAMasternode()) throw std::runtime_error("This is not a masternode");
     auto& activeMasternode = mnModule.getActiveMasternode();
     auto& mnodeman = mnModule.getMasternodeManager();
@@ -276,9 +277,9 @@ unsigned FindLastPayeePaymentTime(const CBlockIndex* chainTip, const MasternodeP
     return 0u;
 }
 
-std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter, const CBlockIndex* chainTip)
+std::vector<MasternodeListEntry> GetMasternodeList(const RPCContext& ctx, std::string strFilter, const CBlockIndex* chainTip)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
     auto& networkMessageManager = mnModule.getNetworkMessageManager();
     const MasternodePaymentData& paymentData = mnModule.getMasternodePaymentData();
 
@@ -324,9 +325,9 @@ std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter, const
     return masternodeList;
 }
 
-static int StableMasternodeCount()
+static int StableMasternodeCount(const RPCContext& ctx)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
     auto& networkMessageManager = mnModule.getNetworkMessageManager();
     AssertLockHeld(networkMessageManager.cs_process_message);
     int nStable_size = 0;
@@ -353,9 +354,9 @@ static int StableMasternodeCount()
 }
 
 
-static void CountNetworks(int& ipv4, int& ipv6, int& onion)
+static void CountNetworks(const RPCContext& ctx, int& ipv4, int& ipv6, int& onion)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
     auto& networkMessageManager = mnModule.getNetworkMessageManager();
 
     mnModule.getMasternodeManager().Check();
@@ -393,9 +394,9 @@ static unsigned CountEnabled(const std::vector<CMasternode>& masternodes)
     return count;
 }
 
-MasternodeCountData GetMasternodeCounts(const CBlockIndex* chainTip)
+MasternodeCountData GetMasternodeCounts(const RPCContext& ctx, const CBlockIndex* chainTip)
 {
-    const auto& mnModule = GetMasternodeModule();
+    const auto& mnModule = ctx.MasternodeModule();
     auto& networkMessageManager = mnModule.getNetworkMessageManager();
     auto& masternodePayments = mnModule.getMasternodePayments();
 
@@ -405,8 +406,8 @@ MasternodeCountData GetMasternodeCounts(const CBlockIndex* chainTip)
 
     {
         LOCK(networkMessageManager.cs_process_message);
-        CountNetworks(data.ipv4, data.ipv6, data.onion);
-        data.stable = StableMasternodeCount();
+        CountNetworks(ctx, data.ipv4, data.ipv6, data.onion);
+        data.stable = StableMasternodeCount(ctx);
         data.enabledAndActive = CountEnabled(networkMessageManager.masternodes);
         data.total = networkMessageManager.masternodes.size();
     }
diff --git a/divi/src/RpcMasternodeFeatures.h b/divi/src/RpcMasternodeFeatures.h
index c60205b49..84a581fec 100644
--- a/divi/src/RpcMasternodeFeatures.h
+++ b/divi/src/RpcMasternodeFeatures.h
@@ -5,6 +5,7 @@
 #include <stdint.h>
 class CBlockIndex;
 class CKeyStore;
+class RPCContext;
 class StoredMasternodeBroadcasts;
 struct MasternodeStartResult
 {
@@ -55,10 +56,10 @@ struct MasternodeCountData
 /** Relays a broadcast given in serialised form as hex string.  If the signature
  *  is present, then it will replace the signature in the broadcast.  If
  *  updatePing is true, then the masternode ping is re-signed freshly.  */
-MasternodeStartResult RelayMasternodeBroadcast(const std::string& hexData, const std::string& signature, bool updatePing);
+MasternodeStartResult RelayMasternodeBroadcast(const RPCContext& ctx, const std::string& hexData, const std::string& signature, bool updatePing);
 bool SignMasternodeBroadcast(const CKeyStore& keystore, std::string& hexData);
-MasternodeStartResult StartMasternode(const CKeyStore& keyStore, const StoredMasternodeBroadcasts& stored, std::string alias, bool deferRelay);
-ActiveMasternodeStatus GetActiveMasternodeStatus();
-std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter, const CBlockIndex* chainTip);
-MasternodeCountData GetMasternodeCounts(const CBlockIndex* chainTip);
+MasternodeStartResult StartMasternode(const RPCContext& ctx, const CKeyStore& keyStore, const StoredMasternodeBroadcasts& stored, std::string alias, bool deferRelay);
+ActiveMasternodeStatus GetActiveMasternodeStatus(const RPCContext& ctx);
+std::vector<MasternodeListEntry> GetMasternodeList(const RPCContext& ctx, std::string strFilter, const CBlockIndex* chainTip);
+MasternodeCountData GetMasternodeCounts(const RPCContext& ctx, const CBlockIndex* chainTip);
 #endif// RPC_MASTERNODE_FEATURES_H
diff --git a/divi/src/rpcmasternode.cpp b/divi/src/rpcmasternode.cpp
index 684e6d76c..df71a572b 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -5,6 +5,7 @@
 
 #include "activemasternode.h"
 #include <ChainstateManager.h>
+#include <RPCContext.h>
 #include "init.h"
 #include "main.h"
 #include <chain.h>
@@ -293,6 +294,8 @@ Value listmasternodes(const Array& params, bool fHelp, CWallet* pwallet)
             "\nExamples:\n" +
             HelpExampleCli("masternodelist", "") + HelpExampleRpc("masternodelist", ""));
 
+    auto& ctx = RPCContext::Get ();
+
     Array ret;
     const CBlockIndex* pindex;
     {
@@ -302,7 +305,7 @@ Value listmasternodes(const Array& params, bool fHelp, CWallet* pwallet)
         if(!pindex) return 0;
     }
 
-    std::vector<MasternodeListEntry> masternodeList = GetMasternodeList(strFilter,pindex);
+    std::vector<MasternodeListEntry> masternodeList = GetMasternodeList(ctx, strFilter,pindex);
     ret.reserve(masternodeList.size());
     for(auto& masternodeEntry : masternodeList)
     {
@@ -343,9 +346,10 @@ Value getmasternodecount (const Array& params, bool fHelp, CWallet* pwallet)
             "\nExamples:\n" +
             HelpExampleCli("getmasternodecount", "") + HelpExampleRpc("getmasternodecount", ""));
 
+    auto& ctx = RPCContext::Get ();
     const ChainstateManager::Reference chainstate;
     const CBlockIndex* tip = chainstate->ActiveChain().Tip();
-    MasternodeCountData data = GetMasternodeCounts(tip);
+    MasternodeCountData data = GetMasternodeCounts(ctx, tip);
 
     Object obj;
     obj.push_back(Pair("total", data.total));
@@ -381,7 +385,9 @@ Value broadcaststartmasternode(const Array& params, bool fHelp, CWallet* pwallet
         updatePing = true;
     }
 
-    const auto mnResult = RelayMasternodeBroadcast(params[0].get_str(), signature, updatePing);
+    auto& ctx = RPCContext::Get ();
+
+    const auto mnResult = RelayMasternodeBroadcast(ctx, params[0].get_str(), signature, updatePing);
 
     Object result;
     result.emplace_back("status", mnResult.status ? "success" : "failed");
@@ -407,9 +413,11 @@ Value startmasternode(const Array& params, bool fHelp, CWallet* pwallet)
     const std::string alias = params[0].get_str();
     const bool deferRelay = (params.size() == 1)? false: params[1].get_bool();
 
+    auto& ctx = RPCContext::Get ();
+
     EnsureWalletIsUnlocked(pwallet);
     Object result;
-    MasternodeStartResult mnResult = StartMasternode(*pwallet, GetMasternodeModule().getStoredBroadcasts(), alias, deferRelay);
+    MasternodeStartResult mnResult = StartMasternode(ctx, *pwallet, ctx.MasternodeModule().getStoredBroadcasts(), alias, deferRelay);
 
     result.push_back(Pair("status",mnResult.status?"success":"failed"));
     if(!mnResult.status)
@@ -445,7 +453,9 @@ Value getmasternodestatus (const Array& params, bool fHelp, CWallet* pwallet)
             "\nExamples:\n" +
             HelpExampleCli("getmasternodestatus", "") + HelpExampleRpc("getmasternodestatus", ""));
 
-    const ActiveMasternodeStatus activeMNStatus = GetActiveMasternodeStatus();
+    auto& ctx = RPCContext::Get ();
+
+    const ActiveMasternodeStatus activeMNStatus = GetActiveMasternodeStatus(ctx);
     if(!activeMNStatus.activeMasternodeFound)
     {
         throw std::runtime_error("Masternode not found in the list of available masternodes. Current status: "
@@ -527,6 +537,8 @@ Value getmasternodewinners (const Array& params, bool fHelp, CWallet* pwallet)
             "\nExamples:\n" +
             HelpExampleCli("getmasternodewinners", "") + HelpExampleRpc("getmasternodewinners", ""));
 
+    auto& ctx = RPCContext::Get ();
+
     int nHeight;
     const CBlockIndex* pindex = nullptr;
     {
@@ -548,7 +560,7 @@ Value getmasternodewinners (const Array& params, bool fHelp, CWallet* pwallet)
         strFilter = params[1].get_str();
 
     Array ret;
-    const MasternodePaymentData& paymentData = GetMasternodeModule().getMasternodePaymentData();
+    const MasternodePaymentData& paymentData = ctx.MasternodeModule().getMasternodePaymentData();
     for (int i = nHeight - nLast; i < nHeight + 20; i++) {
         Object obj;
         obj.push_back(Pair("nHeight", i));
@@ -604,13 +616,15 @@ Value importmnbroadcast(const Array& params, bool fHelp, CWallet* pwallet)
                 "\nResult:\n"
                 "true|false          (boolean) true on success\n");
 
+    auto& ctx = RPCContext::Get ();
+
     std::vector<unsigned char> hex = ParseHex(params[0].get_str());
     CDataStream ss(hex,SER_NETWORK,PROTOCOL_VERSION);
 
     CMasternodeBroadcast mnb;
     ss >> mnb;
 
-    return GetMasternodeModule().getStoredBroadcasts().AddBroadcast(mnb);
+    return ctx.MasternodeModule().getStoredBroadcasts().AddBroadcast(mnb);
 }
 
 Value listmnbroadcasts(const Array& params, bool fHelp, CWallet* pwallet)
@@ -629,9 +643,11 @@ Value listmnbroadcasts(const Array& params, bool fHelp, CWallet* pwallet)
             "  }, ...\n"
             "]\n");
 
+    auto& ctx = RPCContext::Get ();
+
     Array res;
 
-    for (const auto& entry : GetMasternodeModule().getStoredBroadcasts().GetMap())
+    for (const auto& entry : ctx.MasternodeModule().getStoredBroadcasts().GetMap())
       {
         const auto& mnb = entry.second;
 
diff --git a/divi/src/rpcmisc.cpp b/divi/src/rpcmisc.cpp
index e8f8f8496..317ea893c 100644
--- a/divi/src/rpcmisc.cpp
+++ b/divi/src/rpcmisc.cpp
@@ -200,9 +200,11 @@ Value mnsync(const Array& params, bool fHelp, CWallet* pwallet)
             HelpExampleCli("mnsync", "\"status\"") + HelpExampleRpc("mnsync", "\"status\""));
     }
 
+    auto& ctx = RPCContext::Get ();
+
     if (strMode == "status") {
         Object obj;
-        const CMasternodeSync& masternodeSynchronization = GetMasternodeModule().getMasternodeSynchronization();
+        const CMasternodeSync& masternodeSynchronization = ctx.MasternodeModule().getMasternodeSynchronization();
         obj.push_back(Pair("IsBlockchainSynced", IsBlockchainSynced()));
         obj.push_back(Pair("timestampOfLastMasternodeListUpdate", masternodeSynchronization.timestampOfLastMasternodeListUpdate));
         obj.push_back(Pair("timestampOfLastMasternodeWinnerUpdate", masternodeSynchronization.timestampOfLastMasternodeWinnerUpdate));
@@ -1057,6 +1059,7 @@ Value getstakingstatus(const Array& params, bool fHelp, CWallet* pwallet)
             "\nExamples:\n" +
             HelpExampleCli("getstakingstatus", "") + HelpExampleRpc("getstakingstatus", ""));
 
+    auto& ctx = RPCContext::Get ();
     const ChainstateManager::Reference chainstate;
 
     Object obj;
@@ -1070,7 +1073,7 @@ Value getstakingstatus(const Array& params, bool fHelp, CWallet* pwallet)
         obj.push_back(Pair("enoughcoins", stakkingBalance > 0 ));
     }
 
-    obj.push_back(Pair("mnsync", GetMasternodeModule().getMasternodeSynchronization().IsSynced()));
+    obj.push_back(Pair("mnsync", ctx.MasternodeModule().getMasternodeSynchronization().IsSynced()));
 
     bool nStaking = HasRecentlyAttemptedToGenerateProofOfStake();
     obj.push_back(Pair("staking status", nStaking));