refactor: s/CJContext/CJWalletManager/g

CJContext is no longer just a context class, it's a lot more involved
now and serves triple duty as also a notification interface and a layer
of abstraction. Name reflects that it's the wallet-specific components
of CoinJoin.

Author: kwvg

src/Makefile.am

@@ -179,10 +179,10 @@ BITCOIN_CORE_H = \
   coinjoin/coinjoin.h \
   coinjoin/client.h \
   coinjoin/common.h \
-  coinjoin/context.h \
   coinjoin/options.h \
   coinjoin/server.h \
   coinjoin/util.h \
+  coinjoin/walletman.h \
   coins.h \
   common/bloom.h \
   compat/assumptions.h \
@@ -485,8 +485,8 @@ libbitcoin_node_a_SOURCES = \
   chainlock/clsig.cpp \
   chainlock/signing.cpp \
   coinjoin/coinjoin.cpp \
-  coinjoin/context.cpp \
   coinjoin/server.cpp \
+  coinjoin/walletman.cpp \
   consensus/tx_verify.cpp \
   dbwrapper.cpp \
   deploymentstatus.cpp \

src/coinjoin/interfaces.cpp

@@ -5,8 +5,8 @@
 #include <interfaces/coinjoin.h>
 
 #include <coinjoin/client.h>
-#include <coinjoin/context.h>
 #include <coinjoin/options.h>
+#include <coinjoin/walletman.h>
 #include <node/context.h>
 #include <util/check.h>
 #include <walletinitinterface.h>
@@ -77,9 +77,9 @@ class CoinJoinClientImpl : public interfaces::CoinJoin::Client
 class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
 {
 private:
-    CJContext& manager()
+    CJWalletManager& manager()
     {
-        return *Assert(m_node.cj_ctx);
+        return *Assert(m_node.cj_walletman);
     }
 
     interfaces::WalletLoader& wallet_loader()

src/coinjoin/context.cpp src/coinjoin/walletman.cppsrc/coinjoin/context.cpp renamed to src/coinjoin/walletman.cpp

@@ -6,7 +6,7 @@
 #include <config/bitcoin-config.h>
 #endif
 
-#include <coinjoin/context.h>
+#include <coinjoin/walletman.h>
 
 #include <net.h>
 #include <scheduler.h>
@@ -21,13 +21,13 @@
 #include <memory>
 
 #ifdef ENABLE_WALLET
-class CJContextImpl final : public CJContext
+class CJWalletManagerImpl final : public CJWalletManager
 {
 public:
-    CJContextImpl(ChainstateManager& chainman, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
-                  CTxMemPool& mempool, const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
-                  bool relay_txes);
-    virtual ~CJContextImpl() = default;
+    CJWalletManagerImpl(ChainstateManager& chainman, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
+                        CTxMemPool& mempool, const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
+                        bool relay_txes);
+    virtual ~CJWalletManagerImpl() = default;
 
 public:
     void Schedule(CConnman& connman, CScheduler& scheduler) override;
@@ -55,16 +55,17 @@ class CJContextImpl final : public CJContext
     const std::unique_ptr<CCoinJoinClientQueueManager> queueman;
 };
 
-CJContextImpl::CJContextImpl(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
-                             CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool, const CMasternodeSync& mn_sync,
-                             const llmq::CInstantSendManager& isman, bool relay_txes) :
+CJWalletManagerImpl::CJWalletManagerImpl(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
+                                         CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
+                                         const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
+                                         bool relay_txes) :
     m_relay_txes{relay_txes},
     walletman{chainman, dmnman, mn_metaman, mempool, mn_sync, isman, queueman},
     queueman{m_relay_txes ? std::make_unique<CCoinJoinClientQueueManager>(walletman, dmnman, mn_metaman, mn_sync) : nullptr}
 {
 }
 
-void CJContextImpl::Schedule(CConnman& connman, CScheduler& scheduler)
+void CJWalletManagerImpl::Schedule(CConnman& connman, CScheduler& scheduler)
 {
     if (!m_relay_txes) return;
     scheduler.scheduleEvery(std::bind(&CCoinJoinClientQueueManager::DoMaintenance, std::ref(*queueman)),
@@ -73,7 +74,7 @@ void CJContextImpl::Schedule(CConnman& connman, CScheduler& scheduler)
                             std::chrono::seconds{1});
 }
 
-void CJContextImpl::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload)
+void CJWalletManagerImpl::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload)
 {
     if (fInitialDownload || pindexNew == pindexFork) // In IBD or blocks were disconnected without any new ones
         return;
@@ -82,21 +83,22 @@ void CJContextImpl::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIn
         [&pindexNew](std::unique_ptr<CCoinJoinClientManager>& clientman) { clientman->UpdatedBlockTip(pindexNew); });
 }
 
-bool CJContextImpl::hasQueue(const uint256& hash) const
+bool CJWalletManagerImpl::hasQueue(const uint256& hash) const
 {
     if (queueman) {
         return queueman->HasQueue(hash);
     }
     return false;
 }
 
-CCoinJoinClientManager* CJContextImpl::getClient(const std::string& name)
+CCoinJoinClientManager* CJWalletManagerImpl::getClient(const std::string& name)
 {
     return walletman.Get(name);
 }
 
-MessageProcessingResult CJContextImpl::processMessage(CNode& pfrom, CChainState& chainstate, CConnman& connman,
-                                                      CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv)
+MessageProcessingResult CJWalletManagerImpl::processMessage(CNode& pfrom, CChainState& chainstate, CConnman& connman,
+                                                            CTxMemPool& mempool, std::string_view msg_type,
+                                                            CDataStream& vRecv)
 {
     walletman.ForEachCJClientMan([&](std::unique_ptr<CCoinJoinClientManager>& clientman) {
         clientman->ProcessMessage(pfrom, chainstate, connman, mempool, msg_type, vRecv);
@@ -107,53 +109,53 @@ MessageProcessingResult CJContextImpl::processMessage(CNode& pfrom, CChainState&
     return {};
 }
 
-std::optional<CCoinJoinQueue> CJContextImpl::getQueueFromHash(const uint256& hash) const
+std::optional<CCoinJoinQueue> CJWalletManagerImpl::getQueueFromHash(const uint256& hash) const
 {
     if (queueman) {
         return queueman->GetQueueFromHash(hash);
     }
     return std::nullopt;
 }
 
-std::optional<int> CJContextImpl::getQueueSize() const
+std::optional<int> CJWalletManagerImpl::getQueueSize() const
 {
     if (queueman) {
         return queueman->GetQueueSize();
     }
     return std::nullopt;
 }
 
-std::vector<CDeterministicMNCPtr> CJContextImpl::getMixingMasternodes()
+std::vector<CDeterministicMNCPtr> CJWalletManagerImpl::getMixingMasternodes()
 {
     std::vector<CDeterministicMNCPtr> ret{};
     walletman.ForEachCJClientMan(
         [&](const std::unique_ptr<CCoinJoinClientManager>& clientman) { clientman->GetMixingMasternodesInfo(ret); });
     return ret;
 }
 
-void CJContextImpl::addWallet(const std::shared_ptr<wallet::CWallet>& wallet)
+void CJWalletManagerImpl::addWallet(const std::shared_ptr<wallet::CWallet>& wallet)
 {
     walletman.Add(wallet);
 }
 
-void CJContextImpl::flushWallet(const std::string& name)
+void CJWalletManagerImpl::flushWallet(const std::string& name)
 {
     walletman.Flush(name);
 }
 
-void CJContextImpl::removeWallet(const std::string& name)
+void CJWalletManagerImpl::removeWallet(const std::string& name)
 {
     walletman.Remove(name);
 }
 #endif // ENABLE_WALLET
 
-std::unique_ptr<CJContext> CJContext::make(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
-                                           CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
-                                           const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
-                                           bool relay_txes)
+std::unique_ptr<CJWalletManager> CJWalletManager::make(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
+                                                       CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
+                                                       const CMasternodeSync& mn_sync,
+                                                       const llmq::CInstantSendManager& isman, bool relay_txes)
 {
 #ifdef ENABLE_WALLET
-    return std::make_unique<CJContextImpl>(chainman, dmnman, mn_metaman, mempool, mn_sync, isman, relay_txes);
+    return std::make_unique<CJWalletManagerImpl>(chainman, dmnman, mn_metaman, mempool, mn_sync, isman, relay_txes);
 #else
     // Cannot be constructed if wallet support isn't built
     return nullptr;

src/coinjoin/context.h src/coinjoin/walletman.hsrc/coinjoin/context.h renamed to src/coinjoin/walletman.h

@@ -2,8 +2,8 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_COINJOIN_CONTEXT_H
-#define BITCOIN_COINJOIN_CONTEXT_H
+#ifndef BITCOIN_COINJOIN_WALLETMAN_H
+#define BITCOIN_COINJOIN_WALLETMAN_H
 
 #include <evo/types.h>
 #include <msg_result.h>
@@ -33,14 +33,14 @@ namespace wallet {
 class CWallet;
 } // namespace wallet
 
-class CJContext : public CValidationInterface
+class CJWalletManager : public CValidationInterface
 {
 public:
-    static std::unique_ptr<CJContext> make(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
-                                           CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
-                                           const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
-                                           bool relay_txes);
-    virtual ~CJContext() = default;
+    static std::unique_ptr<CJWalletManager> make(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
+                                                 CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
+                                                 const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
+                                                 bool relay_txes);
+    virtual ~CJWalletManager() = default;
 
 public:
     virtual void Schedule(CConnman& connman, CScheduler& scheduler) = 0;
@@ -63,4 +63,4 @@ class CJContext : public CValidationInterface
                                  bool fInitialDownload) override = 0;
 };
 
-#endif // BITCOIN_COINJOIN_CONTEXT_H
+#endif // BITCOIN_COINJOIN_WALLETMAN_H

src/init.cpp

@@ -78,8 +78,8 @@
 
 #include <bls/bls.h>
 #include <coinjoin/coinjoin.h>
-#include <coinjoin/context.h>
 #include <coinjoin/server.h>
+#include <coinjoin/walletman.h>
 #include <dsnotificationinterface.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
@@ -326,8 +326,8 @@ void PrepareShutdown(NodeContext& node)
         g_active_notification_interface.reset();
     }
 
-    if (node.cj_ctx) {
-        UnregisterValidationInterface(node.cj_ctx.get());
+    if (node.cj_walletman) {
+        UnregisterValidationInterface(node.cj_walletman.get());
     }
 
     if (g_ds_notification_interface) {
@@ -392,7 +392,7 @@ void PrepareShutdown(NodeContext& node)
 
     // After all wallets are removed, destroy all CoinJoin objects
     // and reset them to nullptr
-    node.cj_ctx.reset();
+    node.cj_walletman.reset();
     node.dstxman.reset();
 
     UnregisterAllValidationInterfaces();
@@ -2134,20 +2134,20 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     assert(!node.dstxman);
     node.dstxman = std::make_unique<CDSTXManager>();
 
-    assert(!node.cj_ctx);
+    assert(!node.cj_walletman);
     if (!node.mn_activeman) {
-        node.cj_ctx = CJContext::make(chainman, *node.dmnman, *node.mn_metaman, *node.mempool, *node.mn_sync,
-                                      *node.llmq_ctx->isman, !ignores_incoming_txs);
+        node.cj_walletman = CJWalletManager::make(chainman, *node.dmnman, *node.mn_metaman, *node.mempool, *node.mn_sync,
+                                                  *node.llmq_ctx->isman, !ignores_incoming_txs);
     }
-    if (node.cj_ctx) {
-        RegisterValidationInterface(node.cj_ctx.get());
+    if (node.cj_walletman) {
+        RegisterValidationInterface(node.cj_walletman.get());
     }
 
     assert(!node.peerman);
     node.peerman = PeerManager::make(chainparams, *node.connman, *node.addrman, node.banman.get(), *node.dstxman,
                                      chainman, *node.mempool, *node.mn_metaman, *node.mn_sync,
                                      *node.govman, *node.sporkman, node.mn_activeman.get(), node.dmnman,
-                                     node.active_ctx, node.cj_ctx.get(), node.llmq_ctx, ignores_incoming_txs);
+                                     node.active_ctx, node.cj_walletman.get(), node.llmq_ctx, ignores_incoming_txs);
     RegisterValidationInterface(node.peerman.get());
 
     g_ds_notification_interface = std::make_unique<CDSNotificationInterface>(
@@ -2267,7 +2267,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     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::cref(*node.peerman), std::cref(*node.govman)), std::chrono::seconds{1});
-    node.scheduler->scheduleEvery(std::bind(&CMasternodeUtils::DoMaintenance, std::ref(*node.connman), std::ref(*node.dmnman), std::ref(*node.mn_sync), node.cj_ctx.get()), std::chrono::minutes{1});
+    node.scheduler->scheduleEvery(std::bind(&CMasternodeUtils::DoMaintenance, std::ref(*node.connman), std::ref(*node.dmnman), std::ref(*node.mn_sync), node.cj_walletman.get()), std::chrono::minutes{1});
     node.scheduler->scheduleEvery(std::bind(&CDeterministicMNManager::DoMaintenance, std::ref(*node.dmnman)), std::chrono::seconds{10});
 
     if (node.govman->IsValid()) {
@@ -2279,8 +2279,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         node.scheduler->scheduleEvery(std::bind(&llmq::CDKGSessionManager::CleanupOldContributions, std::ref(*node.llmq_ctx->qdkgsman)), std::chrono::hours{1});
     }
 
-    if (node.cj_ctx) {
-        node.cj_ctx->Schedule(*node.connman, *node.scheduler);
+    if (node.cj_walletman) {
+        node.cj_walletman->Schedule(*node.connman, *node.scheduler);
     }
 
     if (::g_stats_client->active()) {

src/masternode/utils.cpp

@@ -8,16 +8,12 @@
 #include <shutdown.h>
 #include <util/ranges.h>
 
-#include <coinjoin/context.h>
+#include <coinjoin/walletman.h>
 #include <evo/deterministicmns.h>
 #include <masternode/sync.h>
 
-#ifdef ENABLE_WALLET
-#include <coinjoin/client.h>
-#endif
-
 void CMasternodeUtils::DoMaintenance(CConnman& connman, CDeterministicMNManager& dmnman, const CMasternodeSync& mn_sync,
-                                     CJContext* const cj_ctx)
+                                     CJWalletManager* const cj_walletman)
 {
     if (!mn_sync.IsBlockchainSynced()) return;
     if (ShutdownRequested()) return;
@@ -40,7 +36,7 @@ void CMasternodeUtils::DoMaintenance(CConnman& connman, CDeterministicMNManager&
         return;
     }
 
-    auto mixing_masternodes = cj_ctx ? cj_ctx->getMixingMasternodes() : std::vector<CDeterministicMNCPtr>{};
+    auto mixing_masternodes = cj_walletman ? cj_walletman->getMixingMasternodes() : std::vector<CDeterministicMNCPtr>{};
     connman.ForEachNode(CConnman::AllNodes, [&](CNode* pnode) {
         if (pnode->m_masternode_probe_connection) {
             // we're not disconnecting masternode probes for at least PROBE_WAIT_INTERVAL seconds

src/masternode/utils.h

@@ -8,13 +8,13 @@
 class CConnman;
 class CDeterministicMNManager;
 class CMasternodeSync;
-class CJContext;
+class CJWalletManager;
 
 class CMasternodeUtils
 {
 public:
     static void DoMaintenance(CConnman& connman, CDeterministicMNManager& dmnman, const CMasternodeSync& mn_sync,
-                              CJContext* const cj_ctx);
+                              CJWalletManager* const cj_walletman);
 };
 
 #endif // BITCOIN_MASTERNODE_UTILS_H