Merge #6923: refactor: delete extra ctors from managers, restore memory-only db for EvoDb and LLMQContext

3c85563 fix: keep databases in memory if running unit tests (Kittywhiskers Van Gogh)
8763104 refactor: clean up {c,d}tor for `TestingSetup`s (Kittywhiskers Van Gogh)
5b2e54a refactor: introduce `util::DbWrapperParams` and helper to pull out args (Kittywhiskers Van Gogh)
a7bec54 refactor: move EvoDb cache size to constructor, use `std::unique_ptr` (Kittywhiskers Van Gogh)
556d0b8 refactor: move dtor to source file, delete extra ctors for notif int. (Kittywhiskers Van Gogh)
5dd2e99 refactor: delete extra ctors for netfulfilled, spork (Kittywhiskers Van Gogh)
5163e85 refactor: move ctor/dtor to source file, delete extra ctors for mn (Kittywhiskers Van Gogh)
52f7160 refactor: move ctor/dtor to source file, delete extra ctors for evo (Kittywhiskers Van Gogh)
adb5117 refactor: delete extra ctors for chainlock, instantsend, governance (Kittywhiskers Van Gogh)
301bc70 refactor: move ctor/dtor to source file, delete extra ctors for CoinJoin (Kittywhiskers Van Gogh)
88a2375 refactor: move ctor/dtor to source file, delete extra ctors for LLMQ (Kittywhiskers Van Gogh)

Pull request description:

  ## Additional Information

  * Dependency for #6933

  * There is a mild performance improvement when restoring memory-only databases in unit tests

     **Build arguments:**

     ```bash
     CC=clang CXX=clang++ ./configure --prefix=$(pwd)/depends/arm64-apple-darwin25 --enable-werror --enable-debug --enable-crash-hooks --enable-stacktraces --enable-zmq --enable-suppress-external-warnings --disable-ccache --disable-hardening
     ```

     **develop (b82450a):**

     ```
     $ ttime ./src/test/test_dash
     Running 676 test cases...

     *** No errors detected

     real:    100.50s
     user:    61.92s
     system:  12.90s
     memory:  399920KB
     ```

     **This PR (969e2c45932437e9d5da21dc833cc33ea103d295):**

     ```
     $ ttime ./src/test/test_dash # PR
     Running 676 test cases...

     *** No errors detected

     real:    75.06s
     user:    58.18s
     system:  10.03s
     memory:  394896KB
     ```

  ## Breaking Changes

  None expected.

  ## Checklist

  - [x] I have performed a self-review of my own code
  - [x] I have commented my code, particularly in hard-to-understand areas **(note: N/A)**
  - [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)_

ACKs for top commit:
  UdjinM6:
    utACK 3c85563

Tree-SHA512: 75d6059acb808edd122b492e3fa29e7202c4de4cf02dddbce047e720cf29a92ff20719e6489e2d286ead13a1762a13a67c9631da41dc6de41b7f316933685ed7

Author: PastaPastaPasta

src/bls/bls_worker.h

@@ -49,6 +49,8 @@ class CBLSWorker
     std::vector<SigVerifyJob> sigVerifyQueue;
 
 public:
+    CBLSWorker(const CBLSWorker&) = delete;
+    CBLSWorker& operator=(CBLSWorker const&) = delete;
     CBLSWorker();
     ~CBLSWorker();
 

src/chainlock/chainlock.h

@@ -70,6 +70,9 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
     std::atomic<std::chrono::seconds> lastCleanupTime{0s};
 
 public:
+    CChainLocksHandler() = delete;
+    CChainLocksHandler(const CChainLocksHandler&) = delete;
+    CChainLocksHandler& operator=(const CChainLocksHandler&) = delete;
     explicit CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSporkManager& sporkman,
                                 CTxMemPool& _mempool, const CMasternodeSync& mn_sync);
     ~CChainLocksHandler();

src/chainlock/signing.h

@@ -63,6 +63,9 @@ class ChainLockSigner final : public llmq::CRecoveredSigsListener
     uint256 lastSignedMsgHash GUARDED_BY(cs_signer);
 
 public:
+    ChainLockSigner() = delete;
+    ChainLockSigner(const ChainLockSigner&) = delete;
+    ChainLockSigner& operator=(const ChainLockSigner&) = delete;
     explicit ChainLockSigner(CChainState& chainstate, ChainLockSignerParent& clhandler, llmq::CSigningManager& sigman,
                              llmq::CSigSharesManager& shareman, CSporkManager& sporkman, const CMasternodeSync& mn_sync);
     ~ChainLockSigner();

src/coinjoin/client.cpp

@@ -38,6 +38,17 @@ using wallet::CoinType;
 using wallet::CWallet;
 using wallet::ReserveDestination;
 
+CCoinJoinClientQueueManager::CCoinJoinClientQueueManager(CoinJoinWalletManager& walletman, CDeterministicMNManager& dmnman,
+                                                         CMasternodeMetaMan& mn_metaman, const CMasternodeSync& mn_sync) :
+    m_walletman{walletman},
+    m_dmnman{dmnman},
+    m_mn_metaman{mn_metaman},
+    m_mn_sync{mn_sync}
+{
+}
+
+CCoinJoinClientQueueManager::~CCoinJoinClientQueueManager() = default;
+
 MessageProcessingResult CCoinJoinClientQueueManager::ProcessMessage(NodeId from, CConnman& connman,
                                                                     std::string_view msg_type, CDataStream& vRecv)
 {
@@ -139,6 +150,28 @@ MessageProcessingResult CCoinJoinClientQueueManager::ProcessMessage(NodeId from,
     return ret;
 }
 
+void CCoinJoinClientQueueManager::DoMaintenance()
+{
+    if (!m_mn_sync.IsBlockchainSynced() || ShutdownRequested()) return;
+
+    CheckQueue();
+}
+
+CCoinJoinClientManager::CCoinJoinClientManager(const std::shared_ptr<wallet::CWallet>& wallet,
+                                               CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
+                                               const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
+                                               const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
+    m_wallet{wallet},
+    m_dmnman{dmnman},
+    m_mn_metaman{mn_metaman},
+    m_mn_sync{mn_sync},
+    m_isman{isman},
+    m_queueman{queueman}
+{
+}
+
+CCoinJoinClientManager::~CCoinJoinClientManager() = default;
+
 void CCoinJoinClientManager::ProcessMessage(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv)
 {
     if (!CCoinJoinClientOptions::IsEnabled()) return;
@@ -1816,13 +1849,6 @@ void CCoinJoinClientManager::UpdatedBlockTip(const CBlockIndex* pindex)
     WalletCJLogPrint(m_wallet, "CCoinJoinClientManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", nCachedBlockHeight);
 }
 
-void CCoinJoinClientQueueManager::DoMaintenance()
-{
-    if (!m_mn_sync.IsBlockchainSynced() || ShutdownRequested()) return;
-
-    CheckQueue();
-}
-
 void CCoinJoinClientManager::DoMaintenance(ChainstateManager& chainman, CConnman& connman, const CTxMemPool& mempool)
 {
     if (!CCoinJoinClientOptions::IsEnabled()) return;
@@ -1874,6 +1900,28 @@ void CCoinJoinClientManager::GetJsonInfo(UniValue& obj) const
     obj.pushKV("sessions", arrSessions);
 }
 
+CoinJoinWalletManager::CoinJoinWalletManager(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
+                                             CMasternodeMetaMan& mn_metaman, const CTxMemPool& mempool,
+                                             const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
+                                             const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
+    m_chainman{chainman},
+    m_dmnman{dmnman},
+    m_mn_metaman{mn_metaman},
+    m_mempool{mempool},
+    m_mn_sync{mn_sync},
+    m_isman{isman},
+    m_queueman{queueman}
+{
+}
+
+CoinJoinWalletManager::~CoinJoinWalletManager()
+{
+    LOCK(cs_wallet_manager_map);
+    for (auto& [wallet_name, cj_man] : m_wallet_manager_map) {
+        cj_man.reset();
+    }
+}
+
 void CoinJoinWalletManager::Add(const std::shared_ptr<CWallet>& wallet)
 {
     LOCK(cs_wallet_manager_map);

src/coinjoin/client.h

@@ -75,24 +75,14 @@ class CoinJoinWalletManager {
     using wallet_name_cjman_map = std::map<const std::string, std::unique_ptr<CCoinJoinClientManager>>;
 
 public:
-    CoinJoinWalletManager(ChainstateManager& chainman, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
-                          const CTxMemPool& mempool, const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
-                          const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
-        m_chainman(chainman),
-        m_dmnman(dmnman),
-        m_mn_metaman(mn_metaman),
-        m_mempool(mempool),
-        m_mn_sync(mn_sync),
-        m_isman{isman},
-        m_queueman(queueman)
-    {}
-
-    ~CoinJoinWalletManager() {
-        LOCK(cs_wallet_manager_map);
-        for (auto& [wallet_name, cj_man] : m_wallet_manager_map) {
-            cj_man.reset();
-        }
-    }
+    CoinJoinWalletManager() = delete;
+    CoinJoinWalletManager(const CoinJoinWalletManager&) = delete;
+    CoinJoinWalletManager& operator=(const CoinJoinWalletManager&) = delete;
+    explicit CoinJoinWalletManager(ChainstateManager& chainman, CDeterministicMNManager& dmnman,
+                                   CMasternodeMetaMan& mn_metaman, const CTxMemPool& mempool,
+                                   const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman,
+                                   const std::unique_ptr<CCoinJoinClientQueueManager>& queueman);
+    ~CoinJoinWalletManager();
 
     void Add(const std::shared_ptr<wallet::CWallet>& wallet) EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet_manager_map);
     void DoMaintenance(CConnman& connman) EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet_manager_map);
@@ -235,14 +225,12 @@ class CCoinJoinClientQueueManager : public CCoinJoinBaseManager
     mutable Mutex cs_ProcessDSQueue;
 
 public:
+    CCoinJoinClientQueueManager() = delete;
+    CCoinJoinClientQueueManager(const CCoinJoinClientQueueManager&) = delete;
+    CCoinJoinClientQueueManager& operator=(const CCoinJoinClientQueueManager&) = delete;
     explicit CCoinJoinClientQueueManager(CoinJoinWalletManager& walletman, CDeterministicMNManager& dmnman,
-                                         CMasternodeMetaMan& mn_metaman, const CMasternodeSync& mn_sync) :
-        m_walletman(walletman),
-        m_dmnman(dmnman),
-        m_mn_metaman(mn_metaman),
-        m_mn_sync(mn_sync)
-    {
-    }
+                                         CMasternodeMetaMan& mn_metaman, const CMasternodeSync& mn_sync);
+    ~CCoinJoinClientQueueManager();
 
     [[nodiscard]] MessageProcessingResult ProcessMessage(NodeId from, CConnman& connman, std::string_view msg_type,
                                                          CDataStream& vRecv)
@@ -285,21 +273,13 @@ class CCoinJoinClientManager
     bool fCreateAutoBackups{true}; // builtin support for automatic backups
 
     CCoinJoinClientManager() = delete;
-    CCoinJoinClientManager(CCoinJoinClientManager const&) = delete;
-    CCoinJoinClientManager& operator=(CCoinJoinClientManager const&) = delete;
-
+    CCoinJoinClientManager(const CCoinJoinClientManager&) = delete;
+    CCoinJoinClientManager& operator=(const CCoinJoinClientManager&) = delete;
     explicit CCoinJoinClientManager(const std::shared_ptr<wallet::CWallet>& wallet, CDeterministicMNManager& dmnman,
                                     CMasternodeMetaMan& mn_metaman, const CMasternodeSync& mn_sync,
                                     const llmq::CInstantSendManager& isman,
-                                    const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
-        m_wallet(wallet),
-        m_dmnman(dmnman),
-        m_mn_metaman(mn_metaman),
-        m_mn_sync(mn_sync),
-        m_isman{isman},
-        m_queueman(queueman)
-    {
-    }
+                                    const std::unique_ptr<CCoinJoinClientQueueManager>& queueman);
+    ~CCoinJoinClientManager();
 
     void ProcessMessage(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv) EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);
 

src/coinjoin/coinjoin.cpp

@@ -122,6 +122,10 @@ void CCoinJoinBaseSession::SetNull()
     nTimeLastSuccessfulStep = GetTime();
 }
 
+CCoinJoinBaseManager::CCoinJoinBaseManager() = default;
+
+CCoinJoinBaseManager::~CCoinJoinBaseManager() = default;
+
 void CCoinJoinBaseManager::SetNull()
 {
     LOCK(cs_vecqueue);
@@ -394,6 +398,10 @@ bilingual_str CoinJoin::GetMessageByID(PoolMessage nMessageID)
     }
 }
 
+CDSTXManager::CDSTXManager() = default;
+
+CDSTXManager::~CDSTXManager() = default;
+
 void CDSTXManager::AddDSTX(const CCoinJoinBroadcastTx& dstx)
 {
     AssertLockNotHeld(cs_mapdstx);

src/coinjoin/coinjoin.h

@@ -331,7 +331,8 @@ class CCoinJoinBaseManager
     void CheckQueue() EXCLUSIVE_LOCKS_REQUIRED(!cs_vecqueue);
 
 public:
-    CCoinJoinBaseManager() = default;
+    CCoinJoinBaseManager();
+    virtual ~CCoinJoinBaseManager();
 
     int GetQueueSize() const EXCLUSIVE_LOCKS_REQUIRED(!cs_vecqueue) { LOCK(cs_vecqueue); return vecCoinJoinQueue.size(); }
     bool GetQueueItemAndTry(CCoinJoinQueue& dsqRet) EXCLUSIVE_LOCKS_REQUIRED(!cs_vecqueue);
@@ -371,7 +372,11 @@ class CDSTXManager
     std::map<uint256, CCoinJoinBroadcastTx> mapDSTX GUARDED_BY(cs_mapdstx);
 
 public:
-    CDSTXManager() = default;
+    CDSTXManager(const CDSTXManager&) = delete;
+    CDSTXManager& operator=(const CDSTXManager&) = delete;
+    CDSTXManager();
+    ~CDSTXManager();
+
     void AddDSTX(const CCoinJoinBroadcastTx& dstx) EXCLUSIVE_LOCKS_REQUIRED(!cs_mapdstx);
     CCoinJoinBroadcastTx GetDSTX(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(!cs_mapdstx);
 

src/coinjoin/server.cpp

@@ -23,6 +23,27 @@
 
 #include <univalue.h>
 
+CCoinJoinServer::CCoinJoinServer(ChainstateManager& chainman, CConnman& _connman, CDeterministicMNManager& dmnman,
+                                 CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
+                                 PeerManager& peerman, const CActiveMasternodeManager& mn_activeman,
+                                 const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman) :
+    m_chainman{chainman},
+    connman{_connman},
+    m_dmnman{dmnman},
+    m_dstxman{dstxman},
+    m_mn_metaman{mn_metaman},
+    mempool{mempool},
+    m_peerman{peerman},
+    m_mn_activeman{mn_activeman},
+    m_mn_sync{mn_sync},
+    m_isman{isman},
+    vecSessionCollaterals{},
+    fUnitTest{false}
+{
+}
+
+CCoinJoinServer::~CCoinJoinServer() = default;
+
 MessageProcessingResult CCoinJoinServer::ProcessMessage(CNode& peer, std::string_view msg_type, CDataStream& vRecv)
 {
     if (!m_mn_sync.IsBlockchainSynced()) return {};

src/coinjoin/server.h

@@ -94,23 +94,14 @@ class CCoinJoinServer : public CCoinJoinBaseSession, public CCoinJoinBaseManager
     void SetNull() override EXCLUSIVE_LOCKS_REQUIRED(cs_coinjoin);
 
 public:
+    CCoinJoinServer() = delete;
+    CCoinJoinServer(const CCoinJoinServer&) = delete;
+    CCoinJoinServer& operator=(const CCoinJoinServer&) = delete;
     explicit CCoinJoinServer(ChainstateManager& chainman, CConnman& _connman, CDeterministicMNManager& dmnman,
                              CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
                              PeerManager& peerman, const CActiveMasternodeManager& mn_activeman,
-                             const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman) :
-        m_chainman(chainman),
-        connman(_connman),
-        m_dmnman(dmnman),
-        m_dstxman(dstxman),
-        m_mn_metaman(mn_metaman),
-        mempool(mempool),
-        m_peerman(peerman),
-        m_mn_activeman(mn_activeman),
-        m_mn_sync(mn_sync),
-        m_isman{isman},
-        vecSessionCollaterals(),
-        fUnitTest(false)
-    {}
+                             const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman);
+    ~CCoinJoinServer();
 
     [[nodiscard]] MessageProcessingResult ProcessMessage(CNode& pfrom, std::string_view msg_type, CDataStream& vRecv);
 

src/dbwrapper.h

@@ -709,4 +709,19 @@ class CDBTransaction {
     }
 };
 
+namespace util {
+struct DbWrapperParams
+{
+    const fs::path path{""};
+    const bool memory{false};
+    const bool wipe{false};
+    const size_t cache_size{1 << 20};
+};
+
+static inline std::unique_ptr<CDBWrapper> MakeDbWrapper(const DbWrapperParams& params)
+{
+    return std::make_unique<CDBWrapper>(params.path, params.cache_size, params.memory, params.wipe);
+}
+} // namespace util
+
 #endif // BITCOIN_DBWRAPPER_H