From 28b12e26479604f46311a0403fe7cd3f38eaf659 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 12 Dec 2023 23:40:10 +0700
Subject: [PATCH 01/22] fix: follow-up bitcoin#15638 to move AnalyzePSBT
 related code

---
 src/Makefile.am            |   2 +
 src/node/psbt.cpp          | 145 +++++++++++++++++++++++++++++++++++++
 src/node/psbt.h            |  53 ++++++++++++++
 src/psbt.cpp               | 132 ---------------------------------
 src/psbt.h                 |  43 -----------
 src/qt/walletview.cpp      |   1 +
 src/rpc/rawtransaction.cpp |   1 +
 src/test/fuzz/psbt.cpp     |   1 +
 8 files changed, 203 insertions(+), 175 deletions(-)
 create mode 100644 src/node/psbt.cpp
 create mode 100644 src/node/psbt.h

diff --git a/src/Makefile.am b/src/Makefile.am
index f181677e7211..965c96202bc2 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -259,6 +259,7 @@ BITCOIN_CORE_H = \
   node/coin.h \
   node/coinstats.h \
   node/context.h \
+  node/psbt.h \
   node/transaction.h \
   node/utxo_snapshot.h \
   noui.h \
@@ -468,6 +469,7 @@ libbitcoin_server_a_SOURCES = \
   node/coinstats.cpp \
   node/context.cpp \
   node/interfaces.cpp \
+  node/psbt.cpp \
   node/transaction.cpp \
   noui.cpp \
   policy/fees.cpp \
diff --git a/src/node/psbt.cpp b/src/node/psbt.cpp
new file mode 100644
index 000000000000..872f98369e93
--- /dev/null
+++ b/src/node/psbt.cpp
@@ -0,0 +1,145 @@
+// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <coins.h>
+#include <consensus/tx_verify.h>
+#include <node/psbt.h>
+#include <policy/policy.h>
+#include <policy/settings.h>
+#include <tinyformat.h>
+
+#include <numeric>
+
+PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
+{
+    // Go through each input and build status
+    PSBTAnalysis result;
+
+    bool calc_fee = true;
+
+    CAmount in_amt = 0;
+
+    result.inputs.resize(psbtx.tx->vin.size());
+
+    for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
+        PSBTInput& input = psbtx.inputs[i];
+        PSBTInputAnalysis& input_analysis = result.inputs[i];
+
+        // We set next role here and ratchet backwards as required
+        input_analysis.next = PSBTRole::EXTRACTOR;
+
+        // Check for a UTXO
+        CTxOut utxo;
+        if (psbtx.GetInputUTXO(utxo, i)) {
+            if (!MoneyRange(utxo.nValue) || !MoneyRange(in_amt + utxo.nValue)) {
+                result.SetInvalid(strprintf("PSBT is not valid. Input %u has invalid value", i));
+                return result;
+            }
+            in_amt += utxo.nValue;
+            input_analysis.has_utxo = true;
+        } else {
+            if (input.non_witness_utxo && psbtx.tx->vin[i].prevout.n >= input.non_witness_utxo->vout.size()) {
+                result.SetInvalid(strprintf("PSBT is not valid. Input %u specifies invalid prevout", i));
+                return result;
+            }
+            input_analysis.has_utxo = false;
+            input_analysis.is_final = false;
+            input_analysis.next = PSBTRole::UPDATER;
+            calc_fee = false;
+        }
+
+        if (!utxo.IsNull() && utxo.scriptPubKey.IsUnspendable()) {
+            result.SetInvalid(strprintf("PSBT is not valid. Input %u spends unspendable output", i));
+            return result;
+        }
+
+        // Check if it is final
+        if (!utxo.IsNull() && !PSBTInputSigned(input)) {
+            input_analysis.is_final = false;
+
+            // Figure out what is missing
+            SignatureData outdata;
+            bool complete = SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, 1, &outdata);
+
+            // Things are missing
+            if (!complete) {
+                input_analysis.missing_pubkeys = outdata.missing_pubkeys;
+                input_analysis.missing_redeem_script = outdata.missing_redeem_script;
+                input_analysis.missing_sigs = outdata.missing_sigs;
+
+                // If we are only missing signatures and nothing else, then next is signer
+                if (outdata.missing_pubkeys.empty() && outdata.missing_redeem_script.IsNull() && !outdata.missing_sigs.empty()) {
+                    input_analysis.next = PSBTRole::SIGNER;
+                } else {
+                    input_analysis.next = PSBTRole::UPDATER;
+                }
+            } else {
+                input_analysis.next = PSBTRole::FINALIZER;
+            }
+        } else if (!utxo.IsNull()){
+            input_analysis.is_final = true;
+        }
+    }
+
+    // Calculate next role for PSBT by grabbing "minumum" PSBTInput next role
+    result.next = PSBTRole::EXTRACTOR;
+    for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
+        PSBTInputAnalysis& input_analysis = result.inputs[i];
+        result.next = std::min(result.next, input_analysis.next);
+    }
+    assert(result.next > PSBTRole::CREATOR);
+
+    if (calc_fee) {
+        // Get the output amount
+        CAmount out_amt = std::accumulate(psbtx.tx->vout.begin(), psbtx.tx->vout.end(), CAmount(0),
+            [](CAmount a, const CTxOut& b) {
+            if (!MoneyRange(a) || !MoneyRange(b.nValue) || !MoneyRange(a + b.nValue)) {
+                    return CAmount(-1);
+                }
+                return a += b.nValue;
+            }
+        );
+        if (!MoneyRange(out_amt)) {
+            result.SetInvalid(strprintf("PSBT is not valid. Output amount invalid"));
+            return result;
+        }
+
+        // Get the fee
+        CAmount fee = in_amt - out_amt;
+        result.fee = fee;
+
+        // Estimate the size
+        CMutableTransaction mtx(*psbtx.tx);
+        CCoinsView view_dummy;
+        CCoinsViewCache view(&view_dummy);
+        bool success = true;
+
+        for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
+            PSBTInput& input = psbtx.inputs[i];
+            Coin newcoin;
+
+            if (!SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, 1, nullptr, true) || !psbtx.GetInputUTXO(newcoin.out, i)) {
+                success = false;
+                break;
+            } else {
+                mtx.vin[i].scriptSig = input.final_script_sig;
+                newcoin.nHeight = 1;
+                view.AddCoin(psbtx.tx->vin[i].prevout, std::move(newcoin), true);
+            }
+        }
+
+        if (success) {
+            CTransaction ctx = CTransaction(mtx);
+            size_t size = GetVirtualTransactionSize(ctx, GetTransactionSigOpCount(ctx, view, STANDARD_SCRIPT_VERIFY_FLAGS));
+            result.estimated_vsize = size;
+            // Estimate fee rate
+            CFeeRate feerate(fee, size);
+            result.estimated_feerate = feerate;
+        }
+
+    }
+
+    return result;
+}
+
diff --git a/src/node/psbt.h b/src/node/psbt.h
new file mode 100644
index 000000000000..fd2f063351ce
--- /dev/null
+++ b/src/node/psbt.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_NODE_PSBT_H
+#define BITCOIN_NODE_PSBT_H
+
+#include <psbt.h>
+
+/**
+ * Holds an analysis of one input from a PSBT
+ */
+struct PSBTInputAnalysis {
+    bool has_utxo; //!< Whether we have UTXO information for this input
+    bool is_final; //!< Whether the input has all required information including signatures
+    PSBTRole next; //!< Which of the BIP 174 roles needs to handle this input next
+
+    std::vector<CKeyID> missing_pubkeys; //!< Pubkeys whose BIP32 derivation path is missing
+    std::vector<CKeyID> missing_sigs;    //!< Pubkeys whose signatures are missing
+    uint160 missing_redeem_script;       //!< Hash160 of redeem script, if missing
+};
+
+/**
+ * Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
+ */
+struct PSBTAnalysis {
+    std::optional<size_t> estimated_vsize;      //!< Estimated weight of the transaction
+    std::optional<CFeeRate> estimated_feerate;  //!< Estimated feerate (fee / weight) of the transaction
+    std::optional<CAmount> fee;                 //!< Amount of fee being paid by the transaction
+    std::vector<PSBTInputAnalysis> inputs; //!< More information about the individual inputs of the transaction
+    PSBTRole next;                         //!< Which of the BIP 174 roles needs to handle the transaction next
+    std::string error;                     //!< Error message
+
+    void SetInvalid(std::string err_msg)
+    {
+        estimated_vsize = std::nullopt;
+        estimated_feerate = std::nullopt;
+        fee = std::nullopt;
+        inputs.clear();
+        next = PSBTRole::CREATOR;
+        error = err_msg;
+    }
+};
+
+/**
+ * Provides helpful miscellaneous information about where a PSBT is in the signing workflow.
+ *
+ * @param[in] psbtx the PSBT to analyze
+ * @return A PSBTAnalysis with information about the provided PSBT.
+ */
+PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx);
+
+#endif // BITCOIN_PSBT_H
diff --git a/src/psbt.cpp b/src/psbt.cpp
index c5eafb675d51..c6dc7bb0d963 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -316,138 +316,6 @@ std::string PSBTRoleName(PSBTRole role) {
     assert(false);
 }
 
-PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
-{
-    // Go through each input and build status
-    PSBTAnalysis result;
-
-    bool calc_fee = true;
-
-    CAmount in_amt = 0;
-
-    result.inputs.resize(psbtx.tx->vin.size());
-
-    for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
-        PSBTInput& input = psbtx.inputs[i];
-        PSBTInputAnalysis& input_analysis = result.inputs[i];
-
-        // We set next role here and ratchet backwards as required
-        input_analysis.next = PSBTRole::EXTRACTOR;
-
-        // Check for a UTXO
-        CTxOut utxo;
-        if (psbtx.GetInputUTXO(utxo, i)) {
-            if (!MoneyRange(utxo.nValue) || !MoneyRange(in_amt + utxo.nValue)) {
-                result.SetInvalid(strprintf("PSBT is not valid. Input %u has invalid value", i));
-                return result;
-            }
-            in_amt += utxo.nValue;
-            input_analysis.has_utxo = true;
-        } else {
-            if (input.non_witness_utxo && psbtx.tx->vin[i].prevout.n >= input.non_witness_utxo->vout.size()) {
-                result.SetInvalid(strprintf("PSBT is not valid. Input %u specifies invalid prevout", i));
-                return result;
-            }
-            input_analysis.has_utxo = false;
-            input_analysis.is_final = false;
-            input_analysis.next = PSBTRole::UPDATER;
-            calc_fee = false;
-        }
-
-        if (!utxo.IsNull() && utxo.scriptPubKey.IsUnspendable()) {
-            result.SetInvalid(strprintf("PSBT is not valid. Input %u spends unspendable output", i));
-            return result;
-        }
-
-        // Check if it is final
-        if (!utxo.IsNull() && !PSBTInputSigned(input)) {
-            input_analysis.is_final = false;
-
-            // Figure out what is missing
-            SignatureData outdata;
-            bool complete = SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, 1, &outdata);
-
-            // Things are missing
-            if (!complete) {
-                input_analysis.missing_pubkeys = outdata.missing_pubkeys;
-                input_analysis.missing_redeem_script = outdata.missing_redeem_script;
-                input_analysis.missing_sigs = outdata.missing_sigs;
-
-                // If we are only missing signatures and nothing else, then next is signer
-                if (outdata.missing_pubkeys.empty() && outdata.missing_redeem_script.IsNull() && !outdata.missing_sigs.empty()) {
-                    input_analysis.next = PSBTRole::SIGNER;
-                } else {
-                    input_analysis.next = PSBTRole::UPDATER;
-                }
-            } else {
-                input_analysis.next = PSBTRole::FINALIZER;
-            }
-        } else if (!utxo.IsNull()){
-            input_analysis.is_final = true;
-        }
-    }
-
-    // Calculate next role for PSBT by grabbing "minumum" PSBTInput next role
-    result.next = PSBTRole::EXTRACTOR;
-    for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
-        PSBTInputAnalysis& input_analysis = result.inputs[i];
-        result.next = std::min(result.next, input_analysis.next);
-    }
-    assert(result.next > PSBTRole::CREATOR);
-
-    if (calc_fee) {
-        // Get the output amount
-        CAmount out_amt = std::accumulate(psbtx.tx->vout.begin(), psbtx.tx->vout.end(), CAmount(0),
-            [](CAmount a, const CTxOut& b) {
-            if (!MoneyRange(a) || !MoneyRange(b.nValue) || !MoneyRange(a + b.nValue)) {
-                    return CAmount(-1);
-                }
-                return a += b.nValue;
-            }
-        );
-        if (!MoneyRange(out_amt)) {
-            result.SetInvalid(strprintf("PSBT is not valid. Output amount invalid"));
-            return result;
-        }
-
-        // Get the fee
-        CAmount fee = in_amt - out_amt;
-        result.fee = fee;
-
-        // Estimate the size
-        CMutableTransaction mtx(*psbtx.tx);
-        CCoinsView view_dummy;
-        CCoinsViewCache view(&view_dummy);
-        bool success = true;
-
-        for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
-            PSBTInput& input = psbtx.inputs[i];
-            Coin newcoin;
-
-            if (!SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, 1, nullptr, true) || !psbtx.GetInputUTXO(newcoin.out, i)) {
-                success = false;
-                break;
-            } else {
-                mtx.vin[i].scriptSig = input.final_script_sig;
-                newcoin.nHeight = 1;
-                view.AddCoin(psbtx.tx->vin[i].prevout, std::move(newcoin), true);
-            }
-        }
-
-        if (success) {
-            CTransaction ctx = CTransaction(mtx);
-            size_t size = GetVirtualTransactionSize(ctx, GetTransactionSigOpCount(ctx, view, STANDARD_SCRIPT_VERIFY_FLAGS));
-            result.estimated_vsize = size;
-            // Estimate fee rate
-            CFeeRate feerate(fee, size);
-            result.estimated_feerate = feerate;
-        }
-
-    }
-
-    return result;
-}
-
 bool DecodeBase64PSBT(PartiallySignedTransaction& psbt, const std::string& base64_tx, std::string& error)
 {
     bool invalid;
diff --git a/src/psbt.h b/src/psbt.h
index 05189b9693d6..515226807b74 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -498,41 +498,6 @@ enum class PSBTRole {
     EXTRACTOR
 };
 
-/**
- * Holds an analysis of one input from a PSBT
- */
-struct PSBTInputAnalysis {
-    bool has_utxo; //!< Whether we have UTXO information for this input
-    bool is_final; //!< Whether the input has all required information including signatures
-    PSBTRole next; //!< Which of the BIP 174 roles needs to handle this input next
-
-    std::vector<CKeyID> missing_pubkeys; //!< Pubkeys whose BIP32 derivation path is missing
-    std::vector<CKeyID> missing_sigs;    //!< Pubkeys whose signatures are missing
-    uint160 missing_redeem_script;       //!< Hash160 of redeem script, if missing
-};
-
-/**
- * Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
- */
-struct PSBTAnalysis {
-    std::optional<size_t> estimated_vsize;      //!< Estimated weight of the transaction
-    std::optional<CFeeRate> estimated_feerate;  //!< Estimated feerate (fee / weight) of the transaction
-    std::optional<CAmount> fee;                 //!< Amount of fee being paid by the transaction
-    std::vector<PSBTInputAnalysis> inputs; //!< More information about the individual inputs of the transaction
-    PSBTRole next;                         //!< Which of the BIP 174 roles needs to handle the transaction next
-    std::string error;                     //!< Error message
-
-    void SetInvalid(std::string err_msg)
-    {
-        estimated_vsize = std::nullopt;
-        estimated_feerate = std::nullopt;
-        fee = std::nullopt;
-        inputs.clear();
-        next = PSBTRole::CREATOR;
-        error = err_msg;
-    }
-};
-
 std::string PSBTRoleName(PSBTRole role);
 
 /** Checks whether a PSBTInput is already signed. */
@@ -573,14 +538,6 @@ bool FinalizeAndExtractPSBT(PartiallySignedTransaction& psbtx, CMutableTransacti
  */
 [[nodiscard]] TransactionError CombinePSBTs(PartiallySignedTransaction& out, const std::vector<PartiallySignedTransaction>& psbtxs);
 
-/**
- * Provides helpful miscellaneous information about where a PSBT is in the signing workflow.
- *
- * @param[in] psbtx the PSBT to analyze
- * @return A PSBTAnalysis with information about the provided PSBT.
- */
-PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx);
-
 //! Decode a base64ed PSBT into a PartiallySignedTransaction
 [[nodiscard]] bool DecodeBase64PSBT(PartiallySignedTransaction& decoded_psbt, const std::string& base64_psbt, std::string& error);
 //! Decode a raw (binary blob) PSBT into a PartiallySignedTransaction
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index 389e8e5d8f0b..31b00eed552d 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -4,6 +4,7 @@
 
 #include <qt/walletview.h>
 
+#include <node/psbt.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
 #include <qt/addressbookpage.h>
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 8f06aac2b69b..cf1f755e99b5 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -18,6 +18,7 @@
 #include <node/blockstorage.h>
 #include <node/coin.h>
 #include <node/context.h>
+#include <node/psbt.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
diff --git a/src/test/fuzz/psbt.cpp b/src/test/fuzz/psbt.cpp
index 8c01eee2c70d..ce0c27e26964 100644
--- a/src/test/fuzz/psbt.cpp
+++ b/src/test/fuzz/psbt.cpp
@@ -4,6 +4,7 @@
 
 #include <test/fuzz/fuzz.h>
 
+#include <node/psbt.h>
 #include <psbt.h>
 #include <pubkey.h>
 #include <script/script.h>

From b997996f95aefcc1268e28a738b64bc15840791b Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 00:02:55 +0700
Subject: [PATCH 02/22] refactor: new coinjoin/common module with utils code

This code can be used in both server side code and in wallet code
---
 src/Makefile.am              |   3 +
 src/coinjoin/coinjoin.cpp    |  14 ---
 src/coinjoin/coinjoin.h      | 162 ++++-------------------------------
 src/coinjoin/common.cpp      |  26 ++++++
 src/coinjoin/common.h        | 135 +++++++++++++++++++++++++++++
 src/coinjoin/options.h       |   1 +
 src/wallet/coinselection.cpp |   2 +-
 7 files changed, 183 insertions(+), 160 deletions(-)
 create mode 100644 src/coinjoin/common.cpp
 create mode 100644 src/coinjoin/common.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 965c96202bc2..eb493ec51264 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -149,6 +149,7 @@ BITCOIN_CORE_H = \
   clientversion.h \
   coinjoin/coinjoin.h \
   coinjoin/client.h \
+  coinjoin/common.h \
   coinjoin/context.h \
   coinjoin/options.h \
   coinjoin/server.h \
@@ -737,6 +738,8 @@ libbitcoin_util_a_SOURCES = \
   bls/bls_ies.h \
   bls/bls_worker.cpp \
   bls/bls_worker.h \
+  coinjoin/common.cpp \
+  coinjoin/options.cpp \
   support/lockedpool.cpp \
   chainparamsbase.cpp \
   clientversion.cpp \
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 09072bbf8908..76e361e312f4 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -366,20 +366,6 @@ bool CCoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCol
     return true;
 }
 
-std::string CCoinJoin::DenominationToString(int nDenom)
-{
-    switch (CAmount nDenomAmount = DenominationToAmount(nDenom)) {
-        case  0: return "N/A";
-        case -1: return "out-of-bounds";
-        case -2: return "non-denom";
-        case -3: return "to-amount-error";
-        default: return ValueFromAmount(nDenomAmount).getValStr();
-    }
-
-    // shouldn't happen
-    return "to-string-error";
-}
-
 bilingual_str CCoinJoin::GetMessageByID(PoolMessage nMessageID)
 {
     switch (nMessageID) {
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
index 8f56aa61b696..fc2d79871c91 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_COINJOIN_COINJOIN_H
 #define BITCOIN_COINJOIN_COINJOIN_H
 
+#include <coinjoin/common.h>
+
 #include <core_io.h>
 #include <netaddress.h>
 #include <primitives/block.h>
@@ -12,7 +14,6 @@
 #include <sync.h>
 #include <timedata.h>
 #include <univalue.h>
-#include <util/ranges.h>
 #include <util/translation.h>
 #include <version.h>
 
@@ -20,7 +21,6 @@
 #include <optional>
 #include <utility>
 
-class CCoinJoin;
 class CConnman;
 class CBLSPublicKey;
 class CBlockIndex;
@@ -112,26 +112,6 @@ class CCoinJoinStatusUpdate
     }
 };
 
-/** Holds a mixing input
- */
-class CTxDSIn : public CTxIn
-{
-public:
-    // memory only
-    CScript prevPubKey;
-    bool fHasSig{false}; // flag to indicate if signed
-    int nRounds{-10};
-
-    CTxDSIn(const CTxIn& txin, CScript script, int nRounds) :
-        CTxIn(txin),
-        prevPubKey(std::move(script)),
-        nRounds(nRounds)
-    {
-    }
-
-    CTxDSIn() = default;
-};
-
 class CCoinJoinAccept
 {
 public:
@@ -357,139 +337,31 @@ class CCoinJoinBaseManager
     bool GetQueueItemAndTry(CCoinJoinQueue& dsqRet) LOCKS_EXCLUDED(cs_vecqueue);
 };
 
-// helper class
-class CCoinJoin
+// Various helpers and dstx manager implementation
+namespace CCoinJoin
 {
-private:
-    // make constructor, destructor and copying not available
-    CCoinJoin() = default;
-    ~CCoinJoin() = default;
-    CCoinJoin(CCoinJoin const&) = delete;
-    CCoinJoin& operator=(CCoinJoin const&) = delete;
-
-    // static members
-    static constexpr std::array<CAmount, 5> vecStandardDenominations{
-            (10 * COIN) + 10000,
-            (1 * COIN) + 1000,
-            (COIN / 10) + 100,
-            (COIN / 100) + 10,
-            (COIN / 1000) + 1,
-    };
-
-    static Mutex cs_mapdstx;
-    static std::map<uint256, CCoinJoinBroadcastTx> mapDSTX GUARDED_BY(cs_mapdstx);
-
-    static void CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler) LOCKS_EXCLUDED(cs_mapdstx);
+    extern Mutex cs_mapdstx;
 
-public:
-    static constexpr std::array<CAmount, 5> GetStandardDenominations() { return vecStandardDenominations; }
-    static constexpr CAmount GetSmallestDenomination() { return vecStandardDenominations.back(); }
-
-    static constexpr bool IsDenominatedAmount(CAmount nInputAmount) { return AmountToDenomination(nInputAmount) > 0; }
-    static constexpr bool IsValidDenomination(int nDenom) { return DenominationToAmount(nDenom) > 0; }
-
-    /*
-        Return a bitshifted integer representing a denomination in vecStandardDenominations
-        or 0 if none was found
-    */
-    static constexpr int AmountToDenomination(CAmount nInputAmount)
-    {
-        for (size_t i = 0; i < vecStandardDenominations.size(); ++i) {
-            if (nInputAmount == vecStandardDenominations[i]) {
-                return 1 << i;
-            }
-        }
-        return 0;
-    }
-
-    /*
-        Returns:
-        - one of standard denominations from vecStandardDenominations based on the provided bitshifted integer
-        - 0 for non-initialized sessions (nDenom = 0)
-        - a value below 0 if an error occurred while converting from one to another
-    */
-    static constexpr CAmount DenominationToAmount(int nDenom)
-    {
-        if (nDenom == 0) {
-            // not initialized
-            return 0;
-        }
-
-        size_t nMaxDenoms = vecStandardDenominations.size();
-
-        if (nDenom >= (1 << nMaxDenoms) || nDenom < 0) {
-            // out of bounds
-            return -1;
-        }
-
-        if ((nDenom & (nDenom - 1)) != 0) {
-            // non-denom
-            return -2;
-        }
-
-        CAmount nDenomAmount{-3};
-
-        for (size_t i = 0; i < nMaxDenoms; ++i) {
-            if (nDenom & (1 << i)) {
-                nDenomAmount = vecStandardDenominations[i];
-                break;
-            }
-        }
-
-        return nDenomAmount;
-    }
-
-    /*
-    Same as DenominationToAmount but returns a string representation
-    */
-    static std::string DenominationToString(int nDenom);
-
-    static bilingual_str GetMessageByID(PoolMessage nMessageID);
+    bilingual_str GetMessageByID(PoolMessage nMessageID);
 
     /// Get the minimum/maximum number of participants for the pool
-    static int GetMinPoolParticipants();
-    static int GetMaxPoolParticipants();
+    int GetMinPoolParticipants();
+    int GetMaxPoolParticipants();
 
-    static constexpr CAmount GetMaxPoolAmount() { return COINJOIN_ENTRY_MAX_SIZE * vecStandardDenominations.front(); }
+    constexpr CAmount GetMaxPoolAmount() { return COINJOIN_ENTRY_MAX_SIZE * vecStandardDenominations.front(); }
 
     /// If the collateral is valid given by a client
-    static bool IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCollateral);
-    static constexpr CAmount GetCollateralAmount() { return GetSmallestDenomination() / 10; }
-    static constexpr CAmount GetMaxCollateralAmount() { return GetCollateralAmount() * 4; }
+    bool IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCollateral);
 
-    static constexpr bool IsCollateralAmount(CAmount nInputAmount)
-    {
-        // collateral input can be anything between 1x and "max" (including both)
-        return (nInputAmount >= GetCollateralAmount() && nInputAmount <= GetMaxCollateralAmount());
-    }
-
-    static constexpr int CalculateAmountPriority(CAmount nInputAmount)
-    {
-        if (auto optDenom = ranges::find_if_opt(GetStandardDenominations(), [&nInputAmount](const auto& denom) {
-            return nInputAmount == denom;
-        })) {
-            return (float)COIN / *optDenom * 10000;
-        }
-        if (nInputAmount < COIN) {
-            return 20000;
-        }
+    void AddDSTX(const CCoinJoinBroadcastTx& dstx) LOCKS_EXCLUDED(cs_mapdstx);
+    CCoinJoinBroadcastTx GetDSTX(const uint256& hash) LOCKS_EXCLUDED(cs_mapdstx);
 
-        //nondenom return largest first
-        return -1 * (nInputAmount / COIN);
-    }
-
-
-    static void AddDSTX(const CCoinJoinBroadcastTx& dstx) LOCKS_EXCLUDED(cs_mapdstx);
-    static CCoinJoinBroadcastTx GetDSTX(const uint256& hash) LOCKS_EXCLUDED(cs_mapdstx);
+    void UpdatedBlockTip(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync);
+    void NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync);
 
-    static void UpdatedBlockTip(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync);
-    static void NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync);
-
-    static void TransactionAddedToMempool(const CTransactionRef& tx) LOCKS_EXCLUDED(cs_mapdstx);
-    static void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) LOCKS_EXCLUDED(cs_mapdstx);
-    static void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*) LOCKS_EXCLUDED(cs_mapdstx);
-private:
-    static void UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optional<int> nHeight);
+    void TransactionAddedToMempool(const CTransactionRef& tx) LOCKS_EXCLUDED(cs_mapdstx);
+    void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) LOCKS_EXCLUDED(cs_mapdstx);
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*) LOCKS_EXCLUDED(cs_mapdstx);
 };
 
 #endif // BITCOIN_COINJOIN_COINJOIN_H
diff --git a/src/coinjoin/common.cpp b/src/coinjoin/common.cpp
new file mode 100644
index 000000000000..b8e9797664c3
--- /dev/null
+++ b/src/coinjoin/common.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2014-2023 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <coinjoin/common.h>
+
+#include <core_io.h>
+#include <univalue.h>
+
+namespace CCoinJoin
+{
+std::string DenominationToString(int nDenom)
+{
+    switch (CAmount nDenomAmount = DenominationToAmount(nDenom)) {
+        case  0: return "N/A";
+        case -1: return "out-of-bounds";
+        case -2: return "non-denom";
+        case -3: return "to-amount-error";
+        default: return ValueFromAmount(nDenomAmount).getValStr();
+    }
+
+    // shouldn't happen
+    return "to-string-error";
+}
+
+} // namespace CCoinJoin
diff --git a/src/coinjoin/common.h b/src/coinjoin/common.h
new file mode 100644
index 000000000000..ddcbc13297b8
--- /dev/null
+++ b/src/coinjoin/common.h
@@ -0,0 +1,135 @@
+// Copyright (c) 2014-2023 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_COINJOIN_COMMON_H
+#define BITCOIN_COINJOIN_COMMON_H
+
+#include <amount.h>
+#include <primitives/transaction.h>
+
+#include <array>
+#include <string>
+#include <util/ranges.h>
+
+/** Holds a mixing input
+ */
+class CTxDSIn : public CTxIn
+{
+public:
+    // memory only
+    CScript prevPubKey;
+    bool fHasSig{false}; // flag to indicate if signed
+    int nRounds{-10};
+
+    CTxDSIn(const CTxIn& txin, CScript script, int nRounds) :
+        CTxIn(txin),
+        prevPubKey(std::move(script)),
+        nRounds(nRounds)
+    {
+    }
+
+    CTxDSIn() = default;
+};
+
+namespace CCoinJoin
+{
+
+constexpr std::array<CAmount, 5> vecStandardDenominations{
+        (10 * COIN) + 10000,
+        (1 * COIN) + 1000,
+        (COIN / 10) + 100,
+        (COIN / 100) + 10,
+        (COIN / 1000) + 1,
+};
+
+constexpr std::array<CAmount, 5> GetStandardDenominations() { return vecStandardDenominations; }
+constexpr CAmount GetSmallestDenomination() { return vecStandardDenominations.back(); }
+
+/*
+    Return a bitshifted integer representing a denomination in vecStandardDenominations
+    or 0 if none was found
+*/
+constexpr int AmountToDenomination(CAmount nInputAmount)
+{
+    for (size_t i = 0; i < vecStandardDenominations.size(); ++i) {
+        if (nInputAmount == vecStandardDenominations[i]) {
+            return 1 << i;
+        }
+    }
+    return 0;
+}
+
+/*
+    Returns:
+    - one of standard denominations from vecStandardDenominations based on the provided bitshifted integer
+    - 0 for non-initialized sessions (nDenom = 0)
+    - a value below 0 if an error occurred while converting from one to another
+*/
+constexpr CAmount DenominationToAmount(int nDenom)
+{
+    if (nDenom == 0) {
+        // not initialized
+        return 0;
+    }
+
+    size_t nMaxDenoms = vecStandardDenominations.size();
+
+    if (nDenom >= (1 << nMaxDenoms) || nDenom < 0) {
+        // out of bounds
+        return -1;
+    }
+
+    if ((nDenom & (nDenom - 1)) != 0) {
+        // non-denom
+        return -2;
+    }
+
+    CAmount nDenomAmount{-3};
+
+    for (size_t i = 0; i < nMaxDenoms; ++i) {
+        if (nDenom & (1 << i)) {
+            nDenomAmount = vecStandardDenominations[i];
+            break;
+        }
+    }
+
+    return nDenomAmount;
+}
+
+
+constexpr bool IsDenominatedAmount(CAmount nInputAmount) { return AmountToDenomination(nInputAmount) > 0; }
+constexpr bool IsValidDenomination(int nDenom) { return DenominationToAmount(nDenom) > 0; }
+
+/*
+Same as DenominationToAmount but returns a string representation
+*/
+std::string DenominationToString(int nDenom);
+
+constexpr CAmount GetCollateralAmount() { return GetSmallestDenomination() / 10; }
+constexpr CAmount GetMaxCollateralAmount() { return GetCollateralAmount() * 4; }
+
+constexpr bool IsCollateralAmount(CAmount nInputAmount)
+{
+    // collateral input can be anything between 1x and "max" (including both)
+    return (nInputAmount >= GetCollateralAmount() && nInputAmount <= GetMaxCollateralAmount());
+}
+
+constexpr int CalculateAmountPriority(CAmount nInputAmount)
+{
+    if (auto optDenom = ranges::find_if_opt(GetStandardDenominations(), [&nInputAmount](const auto& denom) {
+        return nInputAmount == denom;
+    })) {
+        return (float)COIN / *optDenom * 10000;
+    }
+    if (nInputAmount < COIN) {
+        return 20000;
+    }
+
+    //nondenom return largest first
+    return -1 * (nInputAmount / COIN);
+}
+
+} // namespace CCoinJoin
+
+#endif
diff --git a/src/coinjoin/options.h b/src/coinjoin/options.h
index b0497f2c4073..124ed71dcebd 100644
--- a/src/coinjoin/options.h
+++ b/src/coinjoin/options.h
@@ -9,6 +9,7 @@
 #include <atomic>
 #include <mutex>
 
+// This header is used by both Wallet and Server libraries
 class UniValue;
 
 static constexpr int MIN_COINJOIN_SESSIONS = 1;
diff --git a/src/wallet/coinselection.cpp b/src/wallet/coinselection.cpp
index b86880840903..2ac4bcd8f038 100644
--- a/src/wallet/coinselection.cpp
+++ b/src/wallet/coinselection.cpp
@@ -8,7 +8,7 @@
 #include <util/system.h>
 #include <util/moneystr.h>
 
-#include <coinjoin/coinjoin.h>
+#include <coinjoin/common.h>
 
 #include <optional>
 

From ad48a74a69e38b9c006ce0f7017c3e2ca938fc79 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 10 Jan 2024 00:25:58 +0700
Subject: [PATCH 03/22] refactor: rename namespace CCoinJoin to CoinJoin

---
 src/coinjoin/client.cpp            | 86 +++++++++++++++---------------
 src/coinjoin/coinjoin.cpp          | 56 +++++++++----------
 src/coinjoin/coinjoin.h            |  2 +-
 src/coinjoin/common.cpp            |  4 +-
 src/coinjoin/common.h              |  4 +-
 src/coinjoin/server.cpp            | 40 +++++++-------
 src/dsnotificationinterface.cpp    | 10 ++--
 src/net.cpp                        |  2 +-
 src/net_processing.cpp             | 14 ++---
 src/node/interfaces.cpp            | 12 ++---
 src/wallet/coinselection.cpp       |  6 +--
 src/wallet/interfaces.cpp          |  2 +-
 src/wallet/test/coinjoin_tests.cpp | 16 +++---
 src/wallet/wallet.cpp              | 44 +++++++--------
 14 files changed, 149 insertions(+), 149 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index f20d51a39805..4ba4697fddf4 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -223,7 +223,7 @@ void CCoinJoinClientSession::ProcessMessage(CNode& peer, PeerManager& peerman, C
             return;
         }
 
-        WalletCJLogPrint(m_wallet, "DSCOMPLETE -- nMsgSessionID %d  nMsgMessageID %d (%s)\n", nMsgSessionID, nMsgMessageID, CCoinJoin::GetMessageByID(nMsgMessageID).translated);
+        WalletCJLogPrint(m_wallet, "DSCOMPLETE -- nMsgSessionID %d  nMsgMessageID %d (%s)\n", nMsgSessionID, nMsgMessageID, CoinJoin::GetMessageByID(nMsgMessageID).translated);
 
         CompletedTransaction(nMsgMessageID);
     }
@@ -354,7 +354,7 @@ std::string CCoinJoinClientManager::GetSessionDenoms()
     AssertLockNotHeld(cs_deqsessions);
     LOCK(cs_deqsessions);
     for (const auto& session : deqSessions) {
-        strSessionDenoms += CCoinJoin::DenominationToString(session.nSessionDenom);
+        strSessionDenoms += CoinJoin::DenominationToString(session.nSessionDenom);
         strSessionDenoms += "; ";
     }
     return strSessionDenoms.empty() ? "N/A" : strSessionDenoms;
@@ -410,7 +410,7 @@ bool CCoinJoinClientSession::CheckTimeout()
     UnlockCoins();
     keyHolderStorage.ReturnAll();
     nTimeLastSuccessfulStep = GetTime();
-    strLastMessage = CCoinJoin::GetMessageByID(ERR_SESSION);
+    strLastMessage = CoinJoin::GetMessageByID(ERR_SESSION);
 
     return true;
 }
@@ -511,7 +511,7 @@ void CCoinJoinClientSession::ProcessPoolStateUpdate(CCoinJoinStatusUpdate psssup
         return;
     }
 
-    bilingual_str strMessageTmp = CCoinJoin::GetMessageByID(psssup.nMessageID);
+    bilingual_str strMessageTmp = CoinJoin::GetMessageByID(psssup.nMessageID);
     strAutoDenomResult = _("Masternode:") + Untranslated(" ") + strMessageTmp;
 
     switch (psssup.nStatusUpdate) {
@@ -576,7 +576,7 @@ bool CCoinJoinClientSession::SignFinalTransaction(const CTxMemPool& mempool, con
     // Make sure all inputs/outputs are valid
     PoolMessage nMessageID{MSG_NOERR};
     if (!IsValidInOuts(mempool, finalMutableTransaction.vin, finalMutableTransaction.vout, nMessageID, nullptr)) {
-        WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- ERROR! IsValidInOuts() failed: %s\n", __func__, CCoinJoin::GetMessageByID(nMessageID).translated);
+        WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- ERROR! IsValidInOuts() failed: %s\n", __func__, CoinJoin::GetMessageByID(nMessageID).translated);
         UnlockCoins();
         keyHolderStorage.ReturnAll();
         SetNull();
@@ -691,7 +691,7 @@ void CCoinJoinClientSession::CompletedTransaction(PoolMessage nMessageID)
     }
     UnlockCoins();
     WITH_LOCK(cs_coinjoin, SetNull());
-    strLastMessage = CCoinJoin::GetMessageByID(nMessageID);
+    strLastMessage = CoinJoin::GetMessageByID(nMessageID);
 }
 
 void CCoinJoinClientManager::UpdatedSuccessBlock()
@@ -831,12 +831,12 @@ bool CCoinJoinClientSession::DoAutomaticDenominating(CConnman& connman, CBlockPo
             return false;
         }
 
-        CAmount nValueMin = CCoinJoin::GetSmallestDenomination();
+        CAmount nValueMin = CoinJoin::GetSmallestDenomination();
 
         // if there are no confirmed DS collateral inputs yet
         if (!m_wallet.HasCollateralInputs()) {
             // should have some additional amount for them
-            nValueMin += CCoinJoin::GetMaxCollateralAmount();
+            nValueMin += CoinJoin::GetMaxCollateralAmount();
         }
 
         // including denoms but applying some restrictions
@@ -859,7 +859,7 @@ bool CCoinJoinClientSession::DoAutomaticDenominating(CConnman& connman, CBlockPo
 
         // adjust nBalanceNeedsAnonymized to consume final denom
         if (nBalanceDenominated - nBalanceAnonymized > nBalanceNeedsAnonymized) {
-            auto denoms = CCoinJoin::GetStandardDenominations();
+            auto denoms = CoinJoin::GetStandardDenominations();
             CAmount nAdditionalDenom{0};
             for (const auto& denom : denoms) {
                 if (nBalanceNeedsAnonymized < denom) {
@@ -897,7 +897,7 @@ bool CCoinJoinClientSession::DoAutomaticDenominating(CConnman& connman, CBlockPo
         // Check if we have should create more denominated inputs i.e.
         // there are funds to denominate and denominated balance does not exceed
         // max amount to mix yet.
-        if (nBalanceAnonimizableNonDenom >= nValueMin + CCoinJoin::GetCollateralAmount() && nBalanceToDenominate > 0) {
+        if (nBalanceAnonimizableNonDenom >= nValueMin + CoinJoin::GetCollateralAmount() && nBalanceToDenominate > 0) {
             CreateDenominated(fee_estimator, nBalanceToDenominate);
         }
 
@@ -932,7 +932,7 @@ bool CCoinJoinClientSession::DoAutomaticDenominating(CConnman& connman, CBlockPo
                 return false;
             }
         } else {
-            if (!CCoinJoin::IsCollateralValid(mempool, CTransaction(txMyCollateral))) {
+            if (!CoinJoin::IsCollateralValid(mempool, CTransaction(txMyCollateral))) {
                 WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::DoAutomaticDenominating -- invalid collateral, recreating...\n");
                 if (!CreateCollateralTransaction(txMyCollateral, strReason)) {
                     WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::DoAutomaticDenominating -- create collateral error: %s\n", strReason);
@@ -1091,7 +1091,7 @@ bool CCoinJoinClientSession::JoinExistingQueue(CAmount nBalanceNeedsAnonymized,
 
         // Try to match their denominations if possible, select exact number of denominations
         if (!m_wallet.SelectTxDSInsByDenomination(dsq.nDenom, nBalanceNeedsAnonymized, vecTxDSInTmp)) {
-            WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::JoinExistingQueue -- Couldn't match denomination %d (%s)\n", dsq.nDenom, CCoinJoin::DenominationToString(dsq.nDenom));
+            WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::JoinExistingQueue -- Couldn't match denomination %d (%s)\n", dsq.nDenom, CoinJoin::DenominationToString(dsq.nDenom));
             continue;
         }
 
@@ -1109,7 +1109,7 @@ bool CCoinJoinClientSession::JoinExistingQueue(CAmount nBalanceNeedsAnonymized,
         SetState(POOL_STATE_QUEUE);
         nTimeLastSuccessfulStep = GetTime();
         WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::JoinExistingQueue -- pending connection (from queue): nSessionDenom: %d (%s), addr=%s\n",
-            nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom), dmn->pdmnState->addr.ToString());
+            nSessionDenom, CoinJoin::DenominationToString(nSessionDenom), dmn->pdmnState->addr.ToString());
         strAutoDenomResult = _("Trying to connect...");
         return true;
     }
@@ -1177,7 +1177,7 @@ bool CCoinJoinClientSession::StartNewQueue(CAmount nBalanceNeedsAnonymized, CCon
         while (nSessionDenom == 0) {
             for (auto it = setAmounts.rbegin(); it != setAmounts.rend(); ++it) {
                 if (setAmounts.size() > 1 && GetRandInt(2)) continue;
-                nSessionDenom = CCoinJoin::AmountToDenomination(*it);
+                nSessionDenom = CoinJoin::AmountToDenomination(*it);
                 break;
             }
         }
@@ -1188,7 +1188,7 @@ bool CCoinJoinClientSession::StartNewQueue(CAmount nBalanceNeedsAnonymized, CCon
         SetState(POOL_STATE_QUEUE);
         nTimeLastSuccessfulStep = GetTime();
         WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::StartNewQueue -- pending connection, nSessionDenom: %d (%s), addr=%s\n",
-            nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom), dmn->pdmnState->addr.ToString());
+            nSessionDenom, CoinJoin::DenominationToString(nSessionDenom), dmn->pdmnState->addr.ToString());
         strAutoDenomResult = _("Trying to connect...");
         return true;
     }
@@ -1325,7 +1325,7 @@ bool CCoinJoinClientSession::SelectDenominate(std::string& strErrorRet, std::vec
 
     vecTxDSInRet.clear();
 
-    bool fSelected = m_wallet.SelectTxDSInsByDenomination(nSessionDenom, CCoinJoin::GetMaxPoolAmount(), vecTxDSInRet);
+    bool fSelected = m_wallet.SelectTxDSInsByDenomination(nSessionDenom, CoinJoin::GetMaxPoolAmount(), vecTxDSInRet);
     if (!fSelected) {
         strErrorRet = "Can't select current denominated inputs";
         return false;
@@ -1338,11 +1338,11 @@ bool CCoinJoinClientSession::PrepareDenominate(int nMinRounds, int nMaxRounds, s
 {
     AssertLockHeld(m_wallet.cs_wallet);
 
-    if (!CCoinJoin::IsValidDenomination(nSessionDenom)) {
+    if (!CoinJoin::IsValidDenomination(nSessionDenom)) {
         strErrorRet = "Incorrect session denom";
         return false;
     }
-    CAmount nDenomAmount = CCoinJoin::DenominationToAmount(nSessionDenom);
+    CAmount nDenomAmount = CoinJoin::DenominationToAmount(nSessionDenom);
 
     // NOTE: No need to randomize order of inputs because they were
     // initially shuffled in CWallet::SelectTxDSInsByDenomination already.
@@ -1443,12 +1443,12 @@ bool CCoinJoinClientSession::MakeCollateralAmounts(const CBlockPolicyEstimator&
     if (!CCoinJoinClientOptions::IsEnabled()) return false;
 
     // Denominated input is always a single one, so we can check its amount directly and return early
-    if (!fTryDenominated && tallyItem.vecInputCoins.size() == 1 && CCoinJoin::IsDenominatedAmount(tallyItem.nAmount)) {
+    if (!fTryDenominated && tallyItem.vecInputCoins.size() == 1 && CoinJoin::IsDenominatedAmount(tallyItem.nAmount)) {
         return false;
     }
 
     // Skip single inputs that can be used as collaterals already
-    if (tallyItem.vecInputCoins.size() == 1 && CCoinJoin::IsCollateralAmount(tallyItem.nAmount)) {
+    if (tallyItem.vecInputCoins.size() == 1 && CoinJoin::IsCollateralAmount(tallyItem.nAmount)) {
         return false;
     }
 
@@ -1464,29 +1464,29 @@ bool CCoinJoinClientSession::MakeCollateralAmounts(const CBlockPolicyEstimator&
     WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- Start %s\n", __func__, txBuilder.ToString());
 
     // Skip way too tiny amounts. Smallest we want is minimum collateral amount in a one output tx
-    if (!txBuilder.CouldAddOutput(CCoinJoin::GetCollateralAmount())) {
+    if (!txBuilder.CouldAddOutput(CoinJoin::GetCollateralAmount())) {
         return false;
     }
 
     int nCase{0}; // Just for debug logs
-    if (txBuilder.CouldAddOutputs({CCoinJoin::GetMaxCollateralAmount(), CCoinJoin::GetCollateralAmount()})) {
+    if (txBuilder.CouldAddOutputs({CoinJoin::GetMaxCollateralAmount(), CoinJoin::GetCollateralAmount()})) {
         nCase = 1;
         // <case1>, see TransactionRecord::decomposeTransaction
-        // Out1 == CCoinJoin::GetMaxCollateralAmount()
-        // Out2 >= CCoinJoin::GetCollateralAmount()
+        // Out1 == CoinJoin::GetMaxCollateralAmount()
+        // Out2 >= CoinJoin::GetCollateralAmount()
 
-        txBuilder.AddOutput(CCoinJoin::GetMaxCollateralAmount());
+        txBuilder.AddOutput(CoinJoin::GetMaxCollateralAmount());
         // Note, here we first add a zero amount output to get the remainder after all fees and then assign it
         CTransactionBuilderOutput* out = txBuilder.AddOutput();
         CAmount nAmountLeft = txBuilder.GetAmountLeft();
         // If remainder is denominated add one duff to the fee
-        out->UpdateAmount(CCoinJoin::IsDenominatedAmount(nAmountLeft) ? nAmountLeft - 1 : nAmountLeft);
+        out->UpdateAmount(CoinJoin::IsDenominatedAmount(nAmountLeft) ? nAmountLeft - 1 : nAmountLeft);
 
-    } else if (txBuilder.CouldAddOutputs({CCoinJoin::GetCollateralAmount(), CCoinJoin::GetCollateralAmount()})) {
+    } else if (txBuilder.CouldAddOutputs({CoinJoin::GetCollateralAmount(), CoinJoin::GetCollateralAmount()})) {
         nCase = 2;
         // <case2>, see TransactionRecord::decomposeTransaction
-        // Out1 CCoinJoin::IsCollateralAmount()
-        // Out2 CCoinJoin::IsCollateralAmount()
+        // Out1 CoinJoin::IsCollateralAmount()
+        // Out2 CoinJoin::IsCollateralAmount()
 
         // First add two outputs to get the available value after all fees
         CTransactionBuilderOutput* out1 = txBuilder.AddOutput();
@@ -1495,20 +1495,20 @@ bool CCoinJoinClientSession::MakeCollateralAmounts(const CBlockPolicyEstimator&
         // Create two equal outputs from the available value. This adds one duff to the fee if txBuilder.GetAmountLeft() is odd.
         CAmount nAmountOutputs = txBuilder.GetAmountLeft() / 2;
 
-        assert(CCoinJoin::IsCollateralAmount(nAmountOutputs));
+        assert(CoinJoin::IsCollateralAmount(nAmountOutputs));
 
         out1->UpdateAmount(nAmountOutputs);
         out2->UpdateAmount(nAmountOutputs);
 
-    } else { // still at least possible to add one CCoinJoin::GetCollateralAmount() output
+    } else { // still at least possible to add one CoinJoin::GetCollateralAmount() output
         nCase = 3;
         // <case3>, see TransactionRecord::decomposeTransaction
-        // Out1 CCoinJoin::IsCollateralAmount()
+        // Out1 CoinJoin::IsCollateralAmount()
         // Out2 Skipped
         CTransactionBuilderOutput* out = txBuilder.AddOutput();
         out->UpdateAmount(txBuilder.GetAmountLeft());
 
-        assert(CCoinJoin::IsCollateralAmount(out->GetAmount()));
+        assert(CoinJoin::IsCollateralAmount(out->GetAmount()));
     }
 
     WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- Done with case %d: %s\n", __func__, nCase, txBuilder.ToString());
@@ -1552,8 +1552,8 @@ bool CCoinJoinClientSession::CreateCollateralTransaction(CMutableTransaction& tx
 
     // pay collateral charge in fees
     // NOTE: no need for protobump patch here,
-    // CCoinJoin::IsCollateralAmount in GetCollateralTxDSIn should already take care of this
-    if (txout.nValue >= CCoinJoin::GetCollateralAmount() * 2) {
+    // CoinJoin::IsCollateralAmount in GetCollateralTxDSIn should already take care of this
+    if (txout.nValue >= CoinJoin::GetCollateralAmount() * 2) {
         // make our change address
         CScript scriptChange;
         CTxDestination dest;
@@ -1563,8 +1563,8 @@ bool CCoinJoinClientSession::CreateCollateralTransaction(CMutableTransaction& tx
         scriptChange = GetScriptForDestination(dest);
         reserveDest.KeepDestination();
         // return change
-        txCollateral.vout.emplace_back(txout.nValue - CCoinJoin::GetCollateralAmount(), scriptChange);
-    } else { // txout.nValue < CCoinJoin::GetCollateralAmount() * 2
+        txCollateral.vout.emplace_back(txout.nValue - CoinJoin::GetCollateralAmount(), scriptChange);
+    } else { // txout.nValue < CoinJoin::GetCollateralAmount() * 2
         // create dummy data output only and pay everything as a fee
         txCollateral.vout.emplace_back(0, CScript() << OP_RETURN);
     }
@@ -1618,7 +1618,7 @@ bool CCoinJoinClientSession::CreateDenominated(CBlockPolicyEstimator& fee_estima
     if (!CCoinJoinClientOptions::IsEnabled()) return false;
 
     // denominated input is always a single one, so we can check its amount directly and return early
-    if (tallyItem.vecInputCoins.size() == 1 && CCoinJoin::IsDenominatedAmount(tallyItem.nAmount)) {
+    if (tallyItem.vecInputCoins.size() == 1 && CoinJoin::IsDenominatedAmount(tallyItem.nAmount)) {
         return false;
     }
 
@@ -1635,7 +1635,7 @@ bool CCoinJoinClientSession::CreateDenominated(CBlockPolicyEstimator& fee_estima
 
     // ****** Add an output for mixing collaterals ************ /
 
-    if (fCreateMixingCollaterals && !txBuilder.AddOutput(CCoinJoin::GetMaxCollateralAmount())) {
+    if (fCreateMixingCollaterals && !txBuilder.AddOutput(CoinJoin::GetMaxCollateralAmount())) {
         WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- Failed to add collateral output\n", __func__);
         return false;
     }
@@ -1643,7 +1643,7 @@ bool CCoinJoinClientSession::CreateDenominated(CBlockPolicyEstimator& fee_estima
     // ****** Add outputs for denoms ************ /
 
     bool fAddFinal = true;
-    auto denoms = CCoinJoin::GetStandardDenominations();
+    auto denoms = CoinJoin::GetStandardDenominations();
 
     std::map<CAmount, int> mapDenomCount;
     for (auto nDenomValue : denoms) {
@@ -1659,7 +1659,7 @@ bool CCoinJoinClientSession::CreateDenominated(CBlockPolicyEstimator& fee_estima
     // Now, in this system, so long as we don't reach COINJOIN_DENOM_OUTPUTS_THRESHOLD outputs the process repeats in
     // the same transaction, creating up to nCoinJoinDenomsHardCap per denomination in a single transaction.
 
-    while (txBuilder.CouldAddOutput(CCoinJoin::GetSmallestDenomination()) && txBuilder.CountOutputs() < COINJOIN_DENOM_OUTPUTS_THRESHOLD) {
+    while (txBuilder.CouldAddOutput(CoinJoin::GetSmallestDenomination()) && txBuilder.CountOutputs() < COINJOIN_DENOM_OUTPUTS_THRESHOLD) {
         for (auto it = denoms.rbegin(); it != denoms.rend(); ++it) {
             CAmount nDenomValue = *it;
             auto currentDenomIt = mapDenomCount.find(nDenomValue);
@@ -1719,7 +1719,7 @@ bool CCoinJoinClientSession::CreateDenominated(CBlockPolicyEstimator& fee_estima
     }
 
     // Now that nCoinJoinDenomsGoal worth of each denom have been created or the max number of denoms given the value of the input, do something with the remainder.
-    if (txBuilder.CouldAddOutput(CCoinJoin::GetSmallestDenomination()) && nBalanceToDenominate >= CCoinJoin::GetSmallestDenomination() && txBuilder.CountOutputs() < COINJOIN_DENOM_OUTPUTS_THRESHOLD) {
+    if (txBuilder.CouldAddOutput(CoinJoin::GetSmallestDenomination()) && nBalanceToDenominate >= CoinJoin::GetSmallestDenomination() && txBuilder.CountOutputs() < COINJOIN_DENOM_OUTPUTS_THRESHOLD) {
         CAmount nLargestDenomValue = denoms.front();
 
         WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- 2 - Process remainder: %s\n", __func__, txBuilder.ToString());
@@ -1866,7 +1866,7 @@ void CCoinJoinClientSession::GetJsonInfo(UniValue& obj) const
         obj.pushKV("outpoint",  mixingMasternode->collateralOutpoint.ToStringShort());
         obj.pushKV("service",   mixingMasternode->pdmnState->addr.ToString());
     }
-    obj.pushKV("denomination",  ValueFromAmount(CCoinJoin::DenominationToAmount(nSessionDenom)));
+    obj.pushKV("denomination",  ValueFromAmount(CoinJoin::DenominationToAmount(nSessionDenom)));
     obj.pushKV("state",         GetStateString());
     obj.pushKV("entries_count", GetEntriesCount());
 }
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 76e361e312f4..2b2d9ea66342 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -141,14 +141,14 @@ bool CCoinJoinBroadcastTx::IsValidStructure() const
     if (tx->vin.size() != tx->vout.size()) {
         return false;
     }
-    if (tx->vin.size() < size_t(CCoinJoin::GetMinPoolParticipants())) {
+    if (tx->vin.size() < size_t(CoinJoin::GetMinPoolParticipants())) {
         return false;
     }
-    if (tx->vin.size() > CCoinJoin::GetMaxPoolParticipants() * COINJOIN_ENTRY_MAX_SIZE) {
+    if (tx->vin.size() > CoinJoin::GetMaxPoolParticipants() * COINJOIN_ENTRY_MAX_SIZE) {
         return false;
     }
     return ranges::all_of(tx->vout, [] (const auto& txOut){
-        return CCoinJoin::IsDenominatedAmount(txOut.nValue) && txOut.scriptPubKey.IsPayToPublicKeyHash();
+        return CoinJoin::IsDenominatedAmount(txOut.nValue) && txOut.scriptPubKey.IsPayToPublicKeyHash();
     });
 }
 
@@ -236,9 +236,9 @@ bool CCoinJoinBaseSession::IsValidInOuts(const CTxMemPool& mempool, const std::v
     }
 
     auto checkTxOut = [&](const CTxOut& txout) {
-        if (int nDenom = CCoinJoin::AmountToDenomination(txout.nValue); nDenom != nSessionDenom) {
+        if (int nDenom = CoinJoin::AmountToDenomination(txout.nValue); nDenom != nSessionDenom) {
             LogPrint(BCLog::COINJOIN, "CCoinJoinBaseSession::IsValidInOuts -- ERROR: incompatible denom %d (%s) != nSessionDenom %d (%s)\n",
-                    nDenom, CCoinJoin::DenominationToString(nDenom), nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom));
+                    nDenom, CoinJoin::DenominationToString(nDenom), nSessionDenom, CoinJoin::DenominationToString(nSessionDenom));
             nMessageIDRet = ERR_DENOM;
             if (fConsumeCollateralRet) *fConsumeCollateralRet = true;
             return false;
@@ -308,11 +308,11 @@ bool CCoinJoinBaseSession::IsValidInOuts(const CTxMemPool& mempool, const std::v
 }
 
 // Definitions for static data members
-Mutex CCoinJoin::cs_mapdstx;
-std::map<uint256, CCoinJoinBroadcastTx> CCoinJoin::mapDSTX GUARDED_BY(CCoinJoin::cs_mapdstx);
+Mutex CoinJoin::cs_mapdstx;
+std::map<uint256, CCoinJoinBroadcastTx> CoinJoin::mapDSTX GUARDED_BY(CoinJoin::cs_mapdstx);
 
 // check to make sure the collateral provided by the client is valid
-bool CCoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCollateral)
+bool CoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCollateral)
 {
     if (txCollateral.vout.empty()) return false;
     if (txCollateral.nLockTime != 0) return false;
@@ -324,7 +324,7 @@ bool CCoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCol
         nValueOut += txout.nValue;
 
         if (!txout.scriptPubKey.IsPayToPublicKeyHash() && !txout.scriptPubKey.IsUnspendable()) {
-            LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- Invalid Script, txCollateral=%s", txCollateral.ToString()); /* Continued */
+            LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- Invalid Script, txCollateral=%s", txCollateral.ToString()); /* Continued */
             return false;
         }
     }
@@ -334,31 +334,31 @@ bool CCoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCol
         auto mempoolTx = mempool.get(txin.prevout.hash);
         if (mempoolTx != nullptr) {
             if (mempool.isSpent(txin.prevout) || !llmq::quorumInstantSendManager->IsLocked(txin.prevout.hash)) {
-                LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- spent or non-locked mempool input! txin=%s\n", txin.ToString());
+                LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- spent or non-locked mempool input! txin=%s\n", txin.ToString());
                 return false;
             }
             nValueIn += mempoolTx->vout[txin.prevout.n].nValue;
         } else if (GetUTXOCoin(txin.prevout, coin)) {
             nValueIn += coin.out.nValue;
         } else {
-            LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- Unknown inputs in collateral transaction, txCollateral=%s", txCollateral.ToString()); /* Continued */
+            LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- Unknown inputs in collateral transaction, txCollateral=%s", txCollateral.ToString()); /* Continued */
             return false;
         }
     }
 
     //collateral transactions are required to pay out a small fee to the miners
     if (nValueIn - nValueOut < GetCollateralAmount()) {
-        LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- did not include enough fees in transaction: fees: %d, txCollateral=%s", nValueOut - nValueIn, txCollateral.ToString()); /* Continued */
+        LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- did not include enough fees in transaction: fees: %d, txCollateral=%s", nValueOut - nValueIn, txCollateral.ToString()); /* Continued */
         return false;
     }
 
-    LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- %s", txCollateral.ToString()); /* Continued */
+    LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- %s", txCollateral.ToString()); /* Continued */
 
     {
         LOCK(cs_main);
         TxValidationState validationState;
         if (!AcceptToMemoryPool(::ChainstateActive(), mempool, validationState, MakeTransactionRef(txCollateral), /*bypass_limits=*/false, /*nAbsurdFee=*/DEFAULT_MAX_RAW_TX_FEE, /*test_accept=*/true)) {
-            LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- didn't pass AcceptToMemoryPool()\n");
+            LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- didn't pass AcceptToMemoryPool()\n");
             return false;
         }
     }
@@ -366,7 +366,7 @@ bool CCoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCol
     return true;
 }
 
-bilingual_str CCoinJoin::GetMessageByID(PoolMessage nMessageID)
+bilingual_str CoinJoin::GetMessageByID(PoolMessage nMessageID)
 {
     switch (nMessageID) {
     case ERR_ALREADY_HAVE:
@@ -418,14 +418,14 @@ bilingual_str CCoinJoin::GetMessageByID(PoolMessage nMessageID)
     }
 }
 
-void CCoinJoin::AddDSTX(const CCoinJoinBroadcastTx& dstx)
+void CoinJoin::AddDSTX(const CCoinJoinBroadcastTx& dstx)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
     mapDSTX.insert(std::make_pair(dstx.tx->GetHash(), dstx));
 }
 
-CCoinJoinBroadcastTx CCoinJoin::GetDSTX(const uint256& hash)
+CCoinJoinBroadcastTx CoinJoin::GetDSTX(const uint256& hash)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -433,7 +433,7 @@ CCoinJoinBroadcastTx CCoinJoin::GetDSTX(const uint256& hash)
     return (it == mapDSTX.end()) ? CCoinJoinBroadcastTx() : it->second;
 }
 
-void CCoinJoin::CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler)
+void CoinJoin::CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -445,24 +445,24 @@ void CCoinJoin::CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHa
             ++it;
         }
     }
-    LogPrint(BCLog::COINJOIN, "CCoinJoin::CheckDSTXes -- mapDSTX.size()=%llu\n", mapDSTX.size());
+    LogPrint(BCLog::COINJOIN, "CoinJoin::CheckDSTXes -- mapDSTX.size()=%llu\n", mapDSTX.size());
 }
 
-void CCoinJoin::UpdatedBlockTip(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
+void CoinJoin::UpdatedBlockTip(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
 {
     if (pindex && mn_sync.IsBlockchainSynced()) {
         CheckDSTXes(pindex, clhandler);
     }
 }
 
-void CCoinJoin::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
+void CoinJoin::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
 {
     if (pindex && mn_sync.IsBlockchainSynced()) {
         CheckDSTXes(pindex, clhandler);
     }
 }
 
-void CCoinJoin::UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optional<int> nHeight)
+void CoinJoin::UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optional<int> nHeight)
 {
     AssertLockHeld(cs_mapdstx);
 
@@ -472,17 +472,17 @@ void CCoinJoin::UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::option
     }
 
     it->second.SetConfirmedHeight(nHeight);
-    LogPrint(BCLog::COINJOIN, "CCoinJoin::%s -- txid=%s, nHeight=%d\n", __func__, tx->GetHash().ToString(), nHeight.value_or(-1));
+    LogPrint(BCLog::COINJOIN, "CoinJoin::%s -- txid=%s, nHeight=%d\n", __func__, tx->GetHash().ToString(), nHeight.value_or(-1));
 }
 
-void CCoinJoin::TransactionAddedToMempool(const CTransactionRef& tx)
+void CoinJoin::TransactionAddedToMempool(const CTransactionRef& tx)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
     UpdateDSTXConfirmedHeight(tx, std::nullopt);
 }
 
-void CCoinJoin::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
+void CoinJoin::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -492,7 +492,7 @@ void CCoinJoin::BlockConnected(const std::shared_ptr<const CBlock>& pblock, cons
     }
 }
 
-void CCoinJoin::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*)
+void CoinJoin::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -501,5 +501,5 @@ void CCoinJoin::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, c
     }
 }
 
-int CCoinJoin::GetMinPoolParticipants() { return Params().PoolMinParticipants(); }
-int CCoinJoin::GetMaxPoolParticipants() { return Params().PoolMaxParticipants(); }
+int CoinJoin::GetMinPoolParticipants() { return Params().PoolMinParticipants(); }
+int CoinJoin::GetMaxPoolParticipants() { return Params().PoolMaxParticipants(); }
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
index fc2d79871c91..967198a44f20 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -338,7 +338,7 @@ class CCoinJoinBaseManager
 };
 
 // Various helpers and dstx manager implementation
-namespace CCoinJoin
+namespace CoinJoin
 {
     extern Mutex cs_mapdstx;
 
diff --git a/src/coinjoin/common.cpp b/src/coinjoin/common.cpp
index b8e9797664c3..c772be1bef6a 100644
--- a/src/coinjoin/common.cpp
+++ b/src/coinjoin/common.cpp
@@ -7,7 +7,7 @@
 #include <core_io.h>
 #include <univalue.h>
 
-namespace CCoinJoin
+namespace CoinJoin
 {
 std::string DenominationToString(int nDenom)
 {
@@ -23,4 +23,4 @@ std::string DenominationToString(int nDenom)
     return "to-string-error";
 }
 
-} // namespace CCoinJoin
+} // namespace CoinJoin
diff --git a/src/coinjoin/common.h b/src/coinjoin/common.h
index ddcbc13297b8..9ff0f734ae4f 100644
--- a/src/coinjoin/common.h
+++ b/src/coinjoin/common.h
@@ -32,7 +32,7 @@ class CTxDSIn : public CTxIn
     CTxDSIn() = default;
 };
 
-namespace CCoinJoin
+namespace CoinJoin
 {
 
 constexpr std::array<CAmount, 5> vecStandardDenominations{
@@ -130,6 +130,6 @@ constexpr int CalculateAmountPriority(CAmount nInputAmount)
     return -1 * (nInputAmount / COIN);
 }
 
-} // namespace CCoinJoin
+} // namespace CoinJoin
 
 #endif
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 9b4b615a57ff..ed36dfdb9045 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -53,7 +53,7 @@ void CCoinJoinServer::ProcessDSACCEPT(CNode& peer, CDataStream& vRecv)
     CCoinJoinAccept dsa;
     vRecv >> dsa;
 
-    LogPrint(BCLog::COINJOIN, "DSACCEPT -- nDenom %d (%s)  txCollateral %s", dsa.nDenom, CCoinJoin::DenominationToString(dsa.nDenom), dsa.txCollateral.ToString()); /* Continued */
+    LogPrint(BCLog::COINJOIN, "DSACCEPT -- nDenom %d (%s)  txCollateral %s", dsa.nDenom, CoinJoin::DenominationToString(dsa.nDenom), dsa.txCollateral.ToString()); /* Continued */
 
     auto mnList = deterministicMNManager->GetListAtChainTip();
     auto dmn = WITH_LOCK(activeMasternodeInfoCs, return mnList.GetValidMNByCollateral(activeMasternodeInfo.outpoint));
@@ -260,7 +260,7 @@ void CCoinJoinServer::CheckPool()
     // Check for Time Out
     // If we timed out while accepting entries, then if we have more than minimum, create final tx
     if (nState == POOL_STATE_ACCEPTING_ENTRIES && CCoinJoinServer::HasTimedOut()
-            && GetEntriesCount() >= CCoinJoin::GetMinPoolParticipants()) {
+            && GetEntriesCount() >= CoinJoin::GetMinPoolParticipants()) {
         // Punish misbehaving participants
         ChargeFees();
         // Try to complete this session ignoring the misbehaving ones
@@ -333,13 +333,13 @@ void CCoinJoinServer::CommitFinalTransaction()
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- CREATING DSTX\n");
 
     // create and sign masternode dstx transaction
-    if (!CCoinJoin::GetDSTX(hashTx)) {
+    if (!CoinJoin::GetDSTX(hashTx)) {
         CCoinJoinBroadcastTx dstxNew(finalTransaction,
                                     WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.outpoint),
                                     WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.proTxHash),
                                     GetAdjustedTime());
         dstxNew.Sign();
-        CCoinJoin::AddDSTX(dstxNew);
+        CoinJoin::AddDSTX(dstxNew);
     }
 
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- TRANSMITTING DSTX\n");
@@ -573,7 +573,7 @@ bool CCoinJoinServer::AddEntry(const CCoinJoinEntry& entry, PoolMessage& nMessag
         return false;
     }
 
-    if (!CCoinJoin::IsCollateralValid(mempool, *entry.txCollateral)) {
+    if (!CoinJoin::IsCollateralValid(mempool, *entry.txCollateral)) {
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR: collateral not valid!\n", __func__);
         nMessageIDRet = ERR_INVALID_COLLATERAL;
         return false;
@@ -608,7 +608,7 @@ bool CCoinJoinServer::AddEntry(const CCoinJoinEntry& entry, PoolMessage& nMessag
 
     bool fConsumeCollateral{false};
     if (!IsValidInOuts(mempool, vin, entry.vecTxOut, nMessageIDRet, &fConsumeCollateral)) {
-        LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR! IsValidInOuts() failed: %s\n", __func__, CCoinJoin::GetMessageByID(nMessageIDRet).translated);
+        LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR! IsValidInOuts() failed: %s\n", __func__, CoinJoin::GetMessageByID(nMessageIDRet).translated);
         if (fConsumeCollateral) {
             ConsumeCollateral(entry.txCollateral);
         }
@@ -617,7 +617,7 @@ bool CCoinJoinServer::AddEntry(const CCoinJoinEntry& entry, PoolMessage& nMessag
 
     WITH_LOCK(cs_coinjoin, vecEntries.push_back(entry));
 
-    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- adding entry %d of %d required\n", __func__, GetEntriesCount(), CCoinJoin::GetMaxPoolParticipants());
+    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- adding entry %d of %d required\n", __func__, GetEntriesCount(), CoinJoin::GetMaxPoolParticipants());
     nMessageIDRet = MSG_ENTRIES_ADDED;
 
     return true;
@@ -677,14 +677,14 @@ bool CCoinJoinServer::IsAcceptableDSA(const CCoinJoinAccept& dsa, PoolMessage& n
     if (!fMasternodeMode) return false;
 
     // is denom even something legit?
-    if (!CCoinJoin::IsValidDenomination(dsa.nDenom)) {
+    if (!CoinJoin::IsValidDenomination(dsa.nDenom)) {
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- denom not valid!\n", __func__);
         nMessageIDRet = ERR_DENOM;
         return false;
     }
 
     // check collateral
-    if (!fUnitTest && !CCoinJoin::IsCollateralValid(mempool, CTransaction(dsa.txCollateral))) {
+    if (!fUnitTest && !CoinJoin::IsCollateralValid(mempool, CTransaction(dsa.txCollateral))) {
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- collateral not valid!\n", __func__);
         nMessageIDRet = ERR_INVALID_COLLATERAL;
         return false;
@@ -729,8 +729,8 @@ bool CCoinJoinServer::CreateNewSession(const CCoinJoinAccept& dsa, PoolMessage&
     }
 
     vecSessionCollaterals.push_back(MakeTransactionRef(dsa.txCollateral));
-    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CreateNewSession -- new session created, nSessionID: %d  nSessionDenom: %d (%s)  vecSessionCollaterals.size(): %d  CCoinJoin::GetMaxPoolParticipants(): %d\n",
-        nSessionID, nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom), vecSessionCollaterals.size(), CCoinJoin::GetMaxPoolParticipants());
+    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CreateNewSession -- new session created, nSessionID: %d  nSessionDenom: %d (%s)  vecSessionCollaterals.size(): %d  CoinJoin::GetMaxPoolParticipants(): %d\n",
+        nSessionID, nSessionDenom, CoinJoin::DenominationToString(nSessionDenom), vecSessionCollaterals.size(), CoinJoin::GetMaxPoolParticipants());
 
     return true;
 }
@@ -752,7 +752,7 @@ bool CCoinJoinServer::AddUserToExistingSession(const CCoinJoinAccept& dsa, PoolM
 
     if (dsa.nDenom != nSessionDenom) {
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddUserToExistingSession -- incompatible denom %d (%s) != nSessionDenom %d (%s)\n",
-            dsa.nDenom, CCoinJoin::DenominationToString(dsa.nDenom), nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom));
+            dsa.nDenom, CoinJoin::DenominationToString(dsa.nDenom), nSessionDenom, CoinJoin::DenominationToString(nSessionDenom));
         nMessageIDRet = ERR_DENOM;
         return false;
     }
@@ -762,8 +762,8 @@ bool CCoinJoinServer::AddUserToExistingSession(const CCoinJoinAccept& dsa, PoolM
     nMessageIDRet = MSG_NOERR;
     vecSessionCollaterals.push_back(MakeTransactionRef(dsa.txCollateral));
 
-    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddUserToExistingSession -- new user accepted, nSessionID: %d  nSessionDenom: %d (%s)  vecSessionCollaterals.size(): %d  CCoinJoin::GetMaxPoolParticipants(): %d\n",
-        nSessionID, nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom), vecSessionCollaterals.size(), CCoinJoin::GetMaxPoolParticipants());
+    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddUserToExistingSession -- new user accepted, nSessionID: %d  nSessionDenom: %d (%s)  vecSessionCollaterals.size(): %d  CoinJoin::GetMaxPoolParticipants(): %d\n",
+        nSessionID, nSessionDenom, CoinJoin::DenominationToString(nSessionDenom), vecSessionCollaterals.size(), CoinJoin::GetMaxPoolParticipants());
 
     return true;
 }
@@ -772,10 +772,10 @@ bool CCoinJoinServer::AddUserToExistingSession(const CCoinJoinAccept& dsa, PoolM
 bool CCoinJoinServer::IsSessionReady() const
 {
     if (nState == POOL_STATE_QUEUE) {
-        if ((int)vecSessionCollaterals.size() >= CCoinJoin::GetMaxPoolParticipants()) {
+        if ((int)vecSessionCollaterals.size() >= CoinJoin::GetMaxPoolParticipants()) {
             return true;
         }
-        if (CCoinJoinServer::HasTimedOut() && (int)vecSessionCollaterals.size() >= CCoinJoin::GetMinPoolParticipants()) {
+        if (CCoinJoinServer::HasTimedOut() && (int)vecSessionCollaterals.size() >= CoinJoin::GetMinPoolParticipants()) {
             return true;
         }
     }
@@ -789,7 +789,7 @@ void CCoinJoinServer::RelayFinalTransaction(const CTransaction& txFinal)
 {
     AssertLockHeld(cs_coinjoin);
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- nSessionID: %d  nSessionDenom: %d (%s)\n",
-        __func__, nSessionID, nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom));
+        __func__, nSessionID, nSessionDenom, CoinJoin::DenominationToString(nSessionDenom));
 
     // final mixing tx with empty signatures should be relayed to mixing participants only
     for (const auto& entry : vecEntries) {
@@ -832,7 +832,7 @@ void CCoinJoinServer::RelayStatus(PoolStatusUpdate nStatusUpdate, PoolMessage nM
 
     // something went wrong
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- can't continue, %llu client(s) disconnected, nSessionID: %d  nSessionDenom: %d (%s)\n",
-        __func__, nDisconnected, nSessionID, nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom));
+        __func__, nDisconnected, nSessionID, nSessionDenom, CoinJoin::DenominationToString(nSessionDenom));
 
     // notify everyone else that this session should be terminated
     for (const auto& entry : vecEntries) {
@@ -853,7 +853,7 @@ void CCoinJoinServer::RelayCompletedTransaction(PoolMessage nMessageID)
 {
     AssertLockNotHeld(cs_coinjoin);
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- nSessionID: %d  nSessionDenom: %d (%s)\n",
-        __func__, nSessionID, nSessionDenom, CCoinJoin::DenominationToString(nSessionDenom));
+        __func__, nSessionID, nSessionDenom, CoinJoin::DenominationToString(nSessionDenom));
 
     // final mixing tx with empty signatures should be relayed to mixing participants only
     LOCK(cs_coinjoin);
@@ -901,7 +901,7 @@ void CCoinJoinServer::GetJsonInfo(UniValue& obj) const
     obj.clear();
     obj.setObject();
     obj.pushKV("queue_size",    GetQueueSize());
-    obj.pushKV("denomination",  ValueFromAmount(CCoinJoin::DenominationToAmount(nSessionDenom)));
+    obj.pushKV("denomination",  ValueFromAmount(CoinJoin::DenominationToAmount(nSessionDenom)));
     obj.pushKV("state",         GetStateString());
     obj.pushKV("entries_count", GetEntriesCount());
 }
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index d933ba3c157e..faee9999dc8c 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -67,7 +67,7 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
     if (fInitialDownload)
         return;
 
-    CCoinJoin::UpdatedBlockTip(pindexNew, *llmq_ctx->clhandler, m_mn_sync);
+    CoinJoin::UpdatedBlockTip(pindexNew, *llmq_ctx->clhandler, m_mn_sync);
 #ifdef ENABLE_WALLET
     for (auto& pair : cj_ctx->clientman->raw()) {
         pair.second->UpdatedBlockTip(pindexNew);
@@ -88,7 +88,7 @@ void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef&
 {
     llmq_ctx->isman->TransactionAddedToMempool(ptx);
     llmq_ctx->clhandler->TransactionAddedToMempool(ptx, nAcceptTime);
-    CCoinJoin::TransactionAddedToMempool(ptx);
+    CoinJoin::TransactionAddedToMempool(ptx);
 }
 
 void CDSNotificationInterface::TransactionRemovedFromMempool(const CTransactionRef& ptx, MemPoolRemovalReason reason)
@@ -100,14 +100,14 @@ void CDSNotificationInterface::BlockConnected(const std::shared_ptr<const CBlock
 {
     llmq_ctx->isman->BlockConnected(pblock, pindex);
     llmq_ctx->clhandler->BlockConnected(pblock, pindex);
-    CCoinJoin::BlockConnected(pblock, pindex);
+    CoinJoin::BlockConnected(pblock, pindex);
 }
 
 void CDSNotificationInterface::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected)
 {
     llmq_ctx->isman->BlockDisconnected(pblock, pindexDisconnected);
     llmq_ctx->clhandler->BlockDisconnected(pblock, pindexDisconnected);
-    CCoinJoin::BlockDisconnected(pblock, pindexDisconnected);
+    CoinJoin::BlockDisconnected(pblock, pindexDisconnected);
 }
 
 void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff)
@@ -119,5 +119,5 @@ void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDet
 void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
 {
     llmq_ctx->isman->NotifyChainLock(pindex);
-    CCoinJoin::NotifyChainLock(pindex, *llmq_ctx->clhandler, m_mn_sync);
+    CoinJoin::NotifyChainLock(pindex, *llmq_ctx->clhandler, m_mn_sync);
 }
diff --git a/src/net.cpp b/src/net.cpp
index 50b8f799e1e3..2deec3d9ba18 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3758,7 +3758,7 @@ void CConnman::RelayTransaction(const CTransaction& tx)
 {
     uint256 hash = tx.GetHash();
     int nInv = MSG_TX;
-    if (CCoinJoin::GetDSTX(hash)) {
+    if (CoinJoin::GetDSTX(hash)) {
         nInv = MSG_DSTX;
     }
     CInv inv(nInv, hash);
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 80de06a66993..797ab8e15c22 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1834,7 +1834,7 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
                                         m_llmq_ctx->isman->IsLocked(inv.hash);
 
             return (!fIgnoreRecentRejects && m_recent_rejects.contains(inv.hash)) ||
-                   (inv.type == MSG_DSTX && static_cast<bool>(CCoinJoin::GetDSTX(inv.hash))) ||
+                   (inv.type == MSG_DSTX && static_cast<bool>(CoinJoin::GetDSTX(inv.hash))) ||
                    m_mempool.exists(inv.hash) ||
                    (g_txindex != nullptr && g_txindex->HasTx(inv.hash));
         }
@@ -1882,7 +1882,7 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
 
 void PeerManagerImpl::RelayTransaction(const uint256& txid)
 {
-    CInv inv(CCoinJoin::GetDSTX(txid) ? MSG_DSTX : MSG_TX, txid);
+    CInv inv(CoinJoin::GetDSTX(txid) ? MSG_DSTX : MSG_TX, txid);
     m_connman.ForEachNode([&inv](CNode* pnode)
     {
         pnode->PushInventory(inv);
@@ -2149,7 +2149,7 @@ void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic
             if (tx) {
                 CCoinJoinBroadcastTx dstx;
                 if (inv.type == MSG_DSTX) {
-                    dstx = CCoinJoin::GetDSTX(inv.hash);
+                    dstx = CoinJoin::GetDSTX(inv.hash);
                 }
                 if (dstx) {
                     m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::DSTX, dstx));
@@ -2731,7 +2731,7 @@ std::pair<bool /*ret*/, bool /*do_return*/> static ValidateDSTX(CTxMemPool& memp
         LogPrint(BCLog::COINJOIN, "DSTX -- Invalid DSTX structure: %s\n", hashTx.ToString());
         return {false, true};
     }
-    if (CCoinJoin::GetDSTX(hashTx)) {
+    if (CoinJoin::GetDSTX(hashTx)) {
         LogPrint(BCLog::COINJOIN, "DSTX -- Already have %s, skipping...\n", hashTx.ToString());
         return {true, true}; // not an error
     }
@@ -3589,7 +3589,7 @@ void PeerManagerImpl::ProcessMessage(
             if (nInvType == MSG_DSTX) {
                 LogPrint(BCLog::COINJOIN, "DSTX -- Masternode transaction accepted, txid=%s, peer=%d\n",
                          tx.GetHash().ToString(), pfrom.GetId());
-                CCoinJoin::AddDSTX(dstx);
+                CoinJoin::AddDSTX(dstx);
             }
 
             m_mempool.check(m_chainman.ActiveChainstate());
@@ -4992,7 +4992,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                         pto->m_tx_relay->setInventoryTxToSend.erase(hash);
                         if (pto->m_tx_relay->pfilter && !pto->m_tx_relay->pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
 
-                        int nInvType = CCoinJoin::GetDSTX(hash) ? MSG_DSTX : MSG_TX;
+                        int nInvType = CoinJoin::GetDSTX(hash) ? MSG_DSTX : MSG_TX;
                         queueAndMaybePushInv(CInv(nInvType, hash));
 
                         const auto islock = m_llmq_ctx->isman->GetInstantSendLockByTxid(hash);
@@ -5061,7 +5061,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                                 vRelayExpiration.push_back(std::make_pair(nNow + std::chrono::microseconds{RELAY_TX_CACHE_TIME}.count(), ret.first));
                             }
                         }
-                        int nInvType = CCoinJoin::GetDSTX(hash) ? MSG_DSTX : MSG_TX;
+                        int nInvType = CoinJoin::GetDSTX(hash) ? MSG_DSTX : MSG_TX;
                         queueAndMaybePushInv(CInv(nInvType, hash));
                     }
                 }
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index cbafaebc7263..1dd7ae52cfed 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -192,27 +192,27 @@ class CoinJoinOptionsImpl : public CoinJoin::Options
     }
     bool isCollateralAmount(CAmount nAmount) override
     {
-        return CCoinJoin::IsCollateralAmount(nAmount);
+        return CoinJoin::IsCollateralAmount(nAmount);
     }
     CAmount getMinCollateralAmount() override
     {
-        return CCoinJoin::GetCollateralAmount();
+        return CoinJoin::GetCollateralAmount();
     }
     CAmount getMaxCollateralAmount() override
     {
-        return CCoinJoin::GetMaxCollateralAmount();
+        return CoinJoin::GetMaxCollateralAmount();
     }
     CAmount getSmallestDenomination() override
     {
-        return CCoinJoin::GetSmallestDenomination();
+        return CoinJoin::GetSmallestDenomination();
     }
     bool isDenominated(CAmount nAmount) override
     {
-        return CCoinJoin::IsDenominatedAmount(nAmount);
+        return CoinJoin::IsDenominatedAmount(nAmount);
     }
     std::array<CAmount, 5> getStandardDenominations() override
     {
-        return CCoinJoin::GetStandardDenominations();
+        return CoinJoin::GetStandardDenominations();
     }
 };
 
diff --git a/src/wallet/coinselection.cpp b/src/wallet/coinselection.cpp
index 2ac4bcd8f038..72e7636f270a 100644
--- a/src/wallet/coinselection.cpp
+++ b/src/wallet/coinselection.cpp
@@ -229,7 +229,7 @@ struct CompareByPriority
     bool operator()(const OutputGroup& group1,
                     const OutputGroup& group2) const
     {
-        return CCoinJoin::CalculateAmountPriority(group1.m_value) > CCoinJoin::CalculateAmountPriority(group2.m_value);
+        return CoinJoin::CalculateAmountPriority(group1.m_value) > CoinJoin::CalculateAmountPriority(group2.m_value);
     }
 };
 
@@ -238,7 +238,7 @@ bool less_then_denom (const OutputGroup& group1, const OutputGroup& group2)
 {
     bool found1 = false;
     bool found2 = false;
-    for (const auto& d : CCoinJoin::GetStandardDenominations()) // loop through predefined denoms
+    for (const auto& d : CoinJoin::GetStandardDenominations()) // loop through predefined denoms
     {
         if(group1.m_value == d) found1 = true;
         if(group2.m_value == d) found2 = true;
@@ -280,7 +280,7 @@ bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& group
         applicable_groups.clear();
         nTotalLower = 0;
         for (const OutputGroup& group : groups) {
-            if (tryDenom == 0 && CCoinJoin::IsDenominatedAmount(group.m_value)) {
+            if (tryDenom == 0 && CoinJoin::IsDenominatedAmount(group.m_value)) {
                 continue; // we don't want denom values on first run
             }
             if (group.m_value == nTargetValue) {
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index eac6a1776fa9..ffdd819071a2 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -69,7 +69,7 @@ WalletTx MakeWalletTx(CWallet& wallet, const CWalletTx& wtx)
         result.txout_address_is_mine.emplace_back(ExtractDestination(txout.scriptPubKey, result.txout_address.back()) ?
                                                       wallet.IsMine(result.txout_address.back()) :
                                                       ISMINE_NO);
-        if (!fOutputDenomFound && result.txout_address_is_mine.back() && CCoinJoin::IsDenominatedAmount(txout.nValue)) {
+        if (!fOutputDenomFound && result.txout_address_is_mine.back() && CoinJoin::IsDenominatedAmount(txout.nValue)) {
             fOutputDenomFound = true;
         }
     }
diff --git a/src/wallet/test/coinjoin_tests.cpp b/src/wallet/test/coinjoin_tests.cpp
index 81ff7aa702f4..387ccd89be2f 100644
--- a/src/wallet/test/coinjoin_tests.cpp
+++ b/src/wallet/test/coinjoin_tests.cpp
@@ -49,16 +49,16 @@ BOOST_AUTO_TEST_CASE(coinjoin_options_tests)
 BOOST_AUTO_TEST_CASE(coinjoin_collateral_tests)
 {
     // Good collateral values
-    static_assert(CCoinJoin::IsCollateralAmount(0.00010000 * COIN));
-    static_assert(CCoinJoin::IsCollateralAmount(0.00012345 * COIN));
-    static_assert(CCoinJoin::IsCollateralAmount(0.00032123 * COIN));
-    static_assert(CCoinJoin::IsCollateralAmount(0.00019000 * COIN));
+    static_assert(CoinJoin::IsCollateralAmount(0.00010000 * COIN));
+    static_assert(CoinJoin::IsCollateralAmount(0.00012345 * COIN));
+    static_assert(CoinJoin::IsCollateralAmount(0.00032123 * COIN));
+    static_assert(CoinJoin::IsCollateralAmount(0.00019000 * COIN));
 
     // Bad collateral values
-    static_assert(!CCoinJoin::IsCollateralAmount(0.00009999 * COIN));
-    static_assert(!CCoinJoin::IsCollateralAmount(0.00040001 * COIN));
-    static_assert(!CCoinJoin::IsCollateralAmount(0.00100000 * COIN));
-    static_assert(!CCoinJoin::IsCollateralAmount(0.00100001 * COIN));
+    static_assert(!CoinJoin::IsCollateralAmount(0.00009999 * COIN));
+    static_assert(!CoinJoin::IsCollateralAmount(0.00040001 * COIN));
+    static_assert(!CoinJoin::IsCollateralAmount(0.00100000 * COIN));
+    static_assert(!CoinJoin::IsCollateralAmount(0.00100001 * COIN));
 }
 
 BOOST_AUTO_TEST_CASE(coinjoin_pending_dsa_request_tests)
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 05090e954ed1..bba52ada0885 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1366,21 +1366,21 @@ int CWallet::GetRealOutpointCoinJoinRounds(const COutPoint& outpoint, int nRound
 
     auto txOutRef = &wtx->tx->vout[outpoint.n];
 
-    if (CCoinJoin::IsCollateralAmount(txOutRef->nValue)) {
+    if (CoinJoin::IsCollateralAmount(txOutRef->nValue)) {
         *nRoundsRef = -3;
         WalletCJLogPrint((*this), "%s UPDATED   %-70s %3d\n", __func__, outpoint.ToStringShort(), *nRoundsRef);
         return *nRoundsRef;
     }
 
     // make sure the final output is non-denominate
-    if (!CCoinJoin::IsDenominatedAmount(txOutRef->nValue)) { //NOT DENOM
+    if (!CoinJoin::IsDenominatedAmount(txOutRef->nValue)) { //NOT DENOM
         *nRoundsRef = -2;
         WalletCJLogPrint((*this), "%s UPDATED   %-70s %3d\n", __func__, outpoint.ToStringShort(), *nRoundsRef);
         return *nRoundsRef;
     }
 
     for (const auto& out : wtx->tx->vout) {
-        if (!CCoinJoin::IsDenominatedAmount(out.nValue)) {
+        if (!CoinJoin::IsDenominatedAmount(out.nValue)) {
             // this one is denominated but there is another non-denominated output found in the same tx
             *nRoundsRef = 0;
             WalletCJLogPrint((*this), "%s UPDATED   %-70s %3d\n", __func__, outpoint.ToStringShort(), *nRoundsRef);
@@ -1429,7 +1429,7 @@ bool CWallet::IsDenominated(const COutPoint& outpoint) const
         return false;
     }
 
-    return CCoinJoin::IsDenominatedAmount(it->second.tx->vout[outpoint.n].nValue);
+    return CoinJoin::IsDenominatedAmount(it->second.tx->vout[outpoint.n].nValue);
 }
 
 bool CWallet::IsFullyMixed(const COutPoint& outpoint) const
@@ -2209,7 +2209,7 @@ CAmount CWalletTx::GetAnonymizedCredit(const CCoinControl* coinControl) const
             continue;
         }
 
-        if (pwallet->IsSpent(hashTx, i) || !CCoinJoin::IsDenominatedAmount(txout.nValue)) continue;
+        if (pwallet->IsSpent(hashTx, i) || !CoinJoin::IsDenominatedAmount(txout.nValue)) continue;
 
         if (pwallet->IsFullyMixed(outpoint)) {
             nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE);
@@ -2256,7 +2256,7 @@ CAmount CWalletTx::GetDenominatedCredit(bool unconfirmed, bool fUseCache) const
     {
         const CTxOut &txout = tx->vout[i];
 
-        if (pwallet->IsSpent(hashTx, i) || !CCoinJoin::IsDenominatedAmount(txout.nValue)) continue;
+        if (pwallet->IsSpent(hashTx, i) || !CoinJoin::IsDenominatedAmount(txout.nValue)) continue;
 
         nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE);
         if (!MoneyRange(nCredit))
@@ -2455,10 +2455,10 @@ CAmount CWallet::GetAnonymizableBalance(bool fSkipDenominated, bool fSkipUnconfi
 
     CAmount nTotal = 0;
 
-    const CAmount nSmallestDenom = CCoinJoin::GetSmallestDenomination();
-    const CAmount nMixingCollateral = CCoinJoin::GetCollateralAmount();
+    const CAmount nSmallestDenom = CoinJoin::GetSmallestDenomination();
+    const CAmount nMixingCollateral = CoinJoin::GetCollateralAmount();
     for (const auto& item : vecTally) {
-        bool fIsDenominated = CCoinJoin::IsDenominatedAmount(item.nAmount);
+        bool fIsDenominated = CoinJoin::IsDenominatedAmount(item.nAmount);
         if(fSkipDenominated && fIsDenominated) continue;
         // assume that the fee to create denoms should be mixing collateral at max
         if(item.nAmount >= nSmallestDenom + (fIsDenominated ? 0 : nMixingCollateral))
@@ -2504,7 +2504,7 @@ CAmount CWallet::GetNormalizedAnonymizedBalance() const
         if (it == mapWallet.end()) continue;
 
         CAmount nValue = it->second.tx->vout[outpoint.n].nValue;
-        if (!CCoinJoin::IsDenominatedAmount(nValue)) continue;
+        if (!CoinJoin::IsDenominatedAmount(nValue)) continue;
         if (it->second.GetDepthInMainChain() < 0) continue;
 
         int nRounds = GetCappedOutpointCoinJoinRounds(outpoint);
@@ -2573,18 +2573,18 @@ void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe, const
         for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) {
             bool found = false;
             if (nCoinType == CoinType::ONLY_FULLY_MIXED) {
-                if (!CCoinJoin::IsDenominatedAmount(pcoin->tx->vout[i].nValue)) continue;
+                if (!CoinJoin::IsDenominatedAmount(pcoin->tx->vout[i].nValue)) continue;
                 found = IsFullyMixed(COutPoint(wtxid, i));
             } else if(nCoinType == CoinType::ONLY_READY_TO_MIX) {
-                if (!CCoinJoin::IsDenominatedAmount(pcoin->tx->vout[i].nValue)) continue;
+                if (!CoinJoin::IsDenominatedAmount(pcoin->tx->vout[i].nValue)) continue;
                 found = !IsFullyMixed(COutPoint(wtxid, i));
             } else if(nCoinType == CoinType::ONLY_NONDENOMINATED) {
-                if (CCoinJoin::IsCollateralAmount(pcoin->tx->vout[i].nValue)) continue; // do not use collateral amounts
-                found = !CCoinJoin::IsDenominatedAmount(pcoin->tx->vout[i].nValue);
+                if (CoinJoin::IsCollateralAmount(pcoin->tx->vout[i].nValue)) continue; // do not use collateral amounts
+                found = !CoinJoin::IsDenominatedAmount(pcoin->tx->vout[i].nValue);
             } else if(nCoinType == CoinType::ONLY_MASTERNODE_COLLATERAL) {
                 found = dmn_types::IsCollateralAmount(pcoin->tx->vout[i].nValue);
             } else if(nCoinType == CoinType::ONLY_COINJOIN_COLLATERAL) {
-                found = CCoinJoin::IsCollateralAmount(pcoin->tx->vout[i].nValue);
+                found = CoinJoin::IsCollateralAmount(pcoin->tx->vout[i].nValue);
             } else {
                 found = true;
             }
@@ -2716,7 +2716,7 @@ struct CompareByPriority
     bool operator()(const COutput& t1,
                     const COutput& t2) const
     {
-        return CCoinJoin::CalculateAmountPriority(t1.GetInputCoin().effective_value) > CCoinJoin::CalculateAmountPriority(t2.GetInputCoin().effective_value);
+        return CoinJoin::CalculateAmountPriority(t1.GetInputCoin().effective_value) > CoinJoin::CalculateAmountPriority(t2.GetInputCoin().effective_value);
     }
 };
 
@@ -3127,10 +3127,10 @@ bool CWallet::SelectTxDSInsByDenomination(int nDenom, CAmount nValueMax, std::ve
 
     vecTxDSInRet.clear();
 
-    if (!CCoinJoin::IsValidDenomination(nDenom)) {
+    if (!CoinJoin::IsValidDenomination(nDenom)) {
         return false;
     }
-    CAmount nDenomAmount = CCoinJoin::DenominationToAmount(nDenom);
+    CAmount nDenomAmount = CoinJoin::DenominationToAmount(nDenom);
 
     CCoinControl coin_control;
     coin_control.nCoinType = CoinType::ONLY_READY_TO_MIX;
@@ -3241,7 +3241,7 @@ std::vector<CompactTallyItem> CWallet::SelectCoinsGroupedByAddresses(bool fSkipD
         }
     }
 
-    CAmount nSmallestDenom = CCoinJoin::GetSmallestDenomination();
+    CAmount nSmallestDenom = CoinJoin::GetSmallestDenomination();
 
     // Tally
     std::map<CTxDestination, CompactTallyItem> mapTally;
@@ -3271,11 +3271,11 @@ std::vector<CompactTallyItem> CWallet::SelectCoinsGroupedByAddresses(bool fSkipD
 
             if(IsSpent(outpoint.hash, i) || IsLockedCoin(outpoint.hash, i)) continue;
 
-            if(fSkipDenominated && CCoinJoin::IsDenominatedAmount(wtx.tx->vout[i].nValue)) continue;
+            if(fSkipDenominated && CoinJoin::IsDenominatedAmount(wtx.tx->vout[i].nValue)) continue;
 
             if(fAnonymizable) {
                 // ignore collaterals
-                if(CCoinJoin::IsCollateralAmount(wtx.tx->vout[i].nValue)) continue;
+                if(CoinJoin::IsCollateralAmount(wtx.tx->vout[i].nValue)) continue;
                 if (fMasternodeMode && dmn_types::IsCollateralAmount(wtx.tx->vout[i].nValue)) continue;
                 // ignore outputs that are 10 times smaller then the smallest denomination
                 // otherwise they will just lead to higher fee / lower priority
@@ -3346,7 +3346,7 @@ bool CWallet::SelectDenominatedAmounts(CAmount nValueMax, std::set<CAmount>& set
         }
     }
 
-    return nValueTotal >= CCoinJoin::GetSmallestDenomination();
+    return nValueTotal >= CoinJoin::GetSmallestDenomination();
 }
 
 int CWallet::CountInputsWithAmount(CAmount nInputAmount) const

From ac1d596219c9d2b67bbe48197f1bdbea91b072b1 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 10 Jan 2024 00:58:06 +0700
Subject: [PATCH 04/22] fix namespace CCoinjoin

---
 src/node/interfaces.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 1dd7ae52cfed..29c3a510d727 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -8,6 +8,7 @@
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <coinjoin/common.h>
 #include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <governance/governance.h>
@@ -192,27 +193,27 @@ class CoinJoinOptionsImpl : public CoinJoin::Options
     }
     bool isCollateralAmount(CAmount nAmount) override
     {
-        return CoinJoin::IsCollateralAmount(nAmount);
+        return ::CoinJoin::IsCollateralAmount(nAmount);
     }
     CAmount getMinCollateralAmount() override
     {
-        return CoinJoin::GetCollateralAmount();
+        return ::CoinJoin::GetCollateralAmount();
     }
     CAmount getMaxCollateralAmount() override
     {
-        return CoinJoin::GetMaxCollateralAmount();
+        return ::CoinJoin::GetMaxCollateralAmount();
     }
     CAmount getSmallestDenomination() override
     {
-        return CoinJoin::GetSmallestDenomination();
+        return ::CoinJoin::GetSmallestDenomination();
     }
     bool isDenominated(CAmount nAmount) override
     {
-        return CoinJoin::IsDenominatedAmount(nAmount);
+        return ::CoinJoin::IsDenominatedAmount(nAmount);
     }
     std::array<CAmount, 5> getStandardDenominations() override
     {
-        return CoinJoin::GetStandardDenominations();
+        return ::CoinJoin::GetStandardDenominations();
     }
 };
 

From 89496e117b67b886270cf7859e396bb1bc6bedd4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 12:13:52 +0700
Subject: [PATCH 05/22] Merge #15639: bitcoin-wallet tool: Drop
 libbitcoin_server.a dependency

---
 src/Makefile.am | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/Makefile.am b/src/Makefile.am
index eb493ec51264..e6179b9d1200 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -402,10 +402,11 @@ libbitcoin_server_a_SOURCES = \
   blockencodings.cpp \
   blockfilter.cpp \
   chain.cpp \
+  coinjoin/client.cpp \
   coinjoin/coinjoin.cpp \
   coinjoin/context.cpp \
-  coinjoin/options.cpp \
   coinjoin/server.cpp \
+  coinjoin/util.cpp \
   consensus/tx_verify.cpp \
   dbwrapper.cpp \
   deploymentstatus.cpp \
@@ -527,9 +528,6 @@ endif
 libbitcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(SQLITE_CFLAGS)
 libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
-  coinjoin/client.cpp \
-  coinjoin/options.cpp \
-  coinjoin/util.cpp \
   hdchain.cpp \
   wallet/coincontrol.cpp \
   wallet/context.cpp \
@@ -875,9 +873,7 @@ endif
 # https://eli.thegreenplace.net/2013/07/09/library-order-in-static-linking#circular-dependency)
 dash_wallet_LDADD = \
   $(LIBBITCOIN_WALLET_TOOL) \
-  $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_WALLET) \
-  $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_COMMON) \
   $(LIBBITCOIN_CONSENSUS) \
   $(LIBBITCOIN_UTIL) \

From e23b07bfa43aaec3b8133e8c79b319fdf96c7ddf Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 01:57:41 +0700
Subject: [PATCH 06/22] refactor: create a new global object dstxManager

Its class CDSTXManager has a lot of ex-static functions and data that
are actually meant to be an object
---
 src/coinjoin/coinjoin.cpp       | 27 +++++++++++++--------------
 src/coinjoin/coinjoin.h         | 20 ++++++++++++++++++--
 src/coinjoin/server.cpp         |  4 ++--
 src/dsnotificationinterface.cpp | 10 +++++-----
 src/init.cpp                    |  5 +++++
 src/net.cpp                     |  2 +-
 src/net_processing.cpp          | 14 +++++++-------
 src/test/util/setup_common.cpp  |  2 ++
 8 files changed, 53 insertions(+), 31 deletions(-)

diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 2b2d9ea66342..9bb932da05b3 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -307,10 +307,6 @@ bool CCoinJoinBaseSession::IsValidInOuts(const CTxMemPool& mempool, const std::v
     return true;
 }
 
-// Definitions for static data members
-Mutex CoinJoin::cs_mapdstx;
-std::map<uint256, CCoinJoinBroadcastTx> CoinJoin::mapDSTX GUARDED_BY(CoinJoin::cs_mapdstx);
-
 // check to make sure the collateral provided by the client is valid
 bool CoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCollateral)
 {
@@ -418,14 +414,17 @@ bilingual_str CoinJoin::GetMessageByID(PoolMessage nMessageID)
     }
 }
 
-void CoinJoin::AddDSTX(const CCoinJoinBroadcastTx& dstx)
+// Definitions for static data members
+std::unique_ptr<CDSTXManager> dstxManager;
+
+void CDSTXManager::AddDSTX(const CCoinJoinBroadcastTx& dstx)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
     mapDSTX.insert(std::make_pair(dstx.tx->GetHash(), dstx));
 }
 
-CCoinJoinBroadcastTx CoinJoin::GetDSTX(const uint256& hash)
+CCoinJoinBroadcastTx CDSTXManager::GetDSTX(const uint256& hash)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -433,7 +432,7 @@ CCoinJoinBroadcastTx CoinJoin::GetDSTX(const uint256& hash)
     return (it == mapDSTX.end()) ? CCoinJoinBroadcastTx() : it->second;
 }
 
-void CoinJoin::CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler)
+void CDSTXManager::CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -448,21 +447,21 @@ void CoinJoin::CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHan
     LogPrint(BCLog::COINJOIN, "CoinJoin::CheckDSTXes -- mapDSTX.size()=%llu\n", mapDSTX.size());
 }
 
-void CoinJoin::UpdatedBlockTip(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
+void CDSTXManager::UpdatedBlockTip(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
 {
     if (pindex && mn_sync.IsBlockchainSynced()) {
         CheckDSTXes(pindex, clhandler);
     }
 }
 
-void CoinJoin::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
+void CDSTXManager::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler, const CMasternodeSync& mn_sync)
 {
     if (pindex && mn_sync.IsBlockchainSynced()) {
         CheckDSTXes(pindex, clhandler);
     }
 }
 
-void CoinJoin::UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optional<int> nHeight)
+void CDSTXManager::UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optional<int> nHeight)
 {
     AssertLockHeld(cs_mapdstx);
 
@@ -472,17 +471,17 @@ void CoinJoin::UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optiona
     }
 
     it->second.SetConfirmedHeight(nHeight);
-    LogPrint(BCLog::COINJOIN, "CoinJoin::%s -- txid=%s, nHeight=%d\n", __func__, tx->GetHash().ToString(), nHeight.value_or(-1));
+    LogPrint(BCLog::COINJOIN, "CDSTXManager::%s -- txid=%s, nHeight=%d\n", __func__, tx->GetHash().ToString(), nHeight.value_or(-1));
 }
 
-void CoinJoin::TransactionAddedToMempool(const CTransactionRef& tx)
+void CDSTXManager::TransactionAddedToMempool(const CTransactionRef& tx)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
     UpdateDSTXConfirmedHeight(tx, std::nullopt);
 }
 
-void CoinJoin::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
+void CDSTXManager::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
@@ -492,7 +491,7 @@ void CoinJoin::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const
     }
 }
 
-void CoinJoin::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*)
+void CDSTXManager::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*)
 {
     AssertLockNotHeld(cs_mapdstx);
     LOCK(cs_mapdstx);
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
index 967198a44f20..c010fac9e690 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -18,6 +18,7 @@
 #include <version.h>
 
 #include <atomic>
+#include <map>
 #include <optional>
 #include <utility>
 
@@ -340,8 +341,6 @@ class CCoinJoinBaseManager
 // Various helpers and dstx manager implementation
 namespace CoinJoin
 {
-    extern Mutex cs_mapdstx;
-
     bilingual_str GetMessageByID(PoolMessage nMessageID);
 
     /// Get the minimum/maximum number of participants for the pool
@@ -353,6 +352,15 @@ namespace CoinJoin
     /// If the collateral is valid given by a client
     bool IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCollateral);
 
+}
+
+class CDSTXManager
+{
+    Mutex cs_mapdstx;
+    std::map<uint256, CCoinJoinBroadcastTx> mapDSTX GUARDED_BY(cs_mapdstx);
+
+public:
+    CDSTXManager() = default;
     void AddDSTX(const CCoinJoinBroadcastTx& dstx) LOCKS_EXCLUDED(cs_mapdstx);
     CCoinJoinBroadcastTx GetDSTX(const uint256& hash) LOCKS_EXCLUDED(cs_mapdstx);
 
@@ -362,6 +370,14 @@ namespace CoinJoin
     void TransactionAddedToMempool(const CTransactionRef& tx) LOCKS_EXCLUDED(cs_mapdstx);
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) LOCKS_EXCLUDED(cs_mapdstx);
     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex*) LOCKS_EXCLUDED(cs_mapdstx);
+
+private:
+    void CheckDSTXes(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler);
+    void UpdateDSTXConfirmedHeight(const CTransactionRef& tx, std::optional<int> nHeight);
+
 };
 
+
+extern std::unique_ptr<CDSTXManager> dstxManager;
+
 #endif // BITCOIN_COINJOIN_COINJOIN_H
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index ed36dfdb9045..c81abb5359f2 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -333,13 +333,13 @@ void CCoinJoinServer::CommitFinalTransaction()
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- CREATING DSTX\n");
 
     // create and sign masternode dstx transaction
-    if (!CoinJoin::GetDSTX(hashTx)) {
+    if (!::dstxManager->GetDSTX(hashTx)) {
         CCoinJoinBroadcastTx dstxNew(finalTransaction,
                                     WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.outpoint),
                                     WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.proTxHash),
                                     GetAdjustedTime());
         dstxNew.Sign();
-        CoinJoin::AddDSTX(dstxNew);
+        ::dstxManager->AddDSTX(dstxNew);
     }
 
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- TRANSMITTING DSTX\n");
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index faee9999dc8c..ca28e605a75c 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -67,7 +67,7 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
     if (fInitialDownload)
         return;
 
-    CoinJoin::UpdatedBlockTip(pindexNew, *llmq_ctx->clhandler, m_mn_sync);
+    ::dstxManager->UpdatedBlockTip(pindexNew, *llmq_ctx->clhandler, m_mn_sync);
 #ifdef ENABLE_WALLET
     for (auto& pair : cj_ctx->clientman->raw()) {
         pair.second->UpdatedBlockTip(pindexNew);
@@ -88,7 +88,7 @@ void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef&
 {
     llmq_ctx->isman->TransactionAddedToMempool(ptx);
     llmq_ctx->clhandler->TransactionAddedToMempool(ptx, nAcceptTime);
-    CoinJoin::TransactionAddedToMempool(ptx);
+    ::dstxManager->TransactionAddedToMempool(ptx);
 }
 
 void CDSNotificationInterface::TransactionRemovedFromMempool(const CTransactionRef& ptx, MemPoolRemovalReason reason)
@@ -100,14 +100,14 @@ void CDSNotificationInterface::BlockConnected(const std::shared_ptr<const CBlock
 {
     llmq_ctx->isman->BlockConnected(pblock, pindex);
     llmq_ctx->clhandler->BlockConnected(pblock, pindex);
-    CoinJoin::BlockConnected(pblock, pindex);
+    ::dstxManager->BlockConnected(pblock, pindex);
 }
 
 void CDSNotificationInterface::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected)
 {
     llmq_ctx->isman->BlockDisconnected(pblock, pindexDisconnected);
     llmq_ctx->clhandler->BlockDisconnected(pblock, pindexDisconnected);
-    CoinJoin::BlockDisconnected(pblock, pindexDisconnected);
+    ::dstxManager->BlockDisconnected(pblock, pindexDisconnected);
 }
 
 void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff)
@@ -119,5 +119,5 @@ void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDet
 void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
 {
     llmq_ctx->isman->NotifyChainLock(pindex);
-    CoinJoin::NotifyChainLock(pindex, *llmq_ctx->clhandler, m_mn_sync);
+    ::dstxManager->NotifyChainLock(pindex, *llmq_ctx->clhandler, m_mn_sync);
 }
diff --git a/src/init.cpp b/src/init.cpp
index ec21e2ee3678..1a6fd61fccc3 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -68,6 +68,7 @@
 #include <validationinterface.h>
 
 #include <masternode/node.h>
+#include <coinjoin/coinjoin.h>
 #include <coinjoin/context.h>
 #ifdef ENABLE_WALLET
 #include <coinjoin/client.h>
@@ -306,6 +307,7 @@ void PrepareShutdown(NodeContext& node)
     ::masternodeSync.reset();
     ::netfulfilledman.reset();
     ::mmetaman.reset();
+    ::dstxManager.reset();
 
     // Stop and delete all indexes only after flushing background callbacks.
     if (g_txindex) {
@@ -2216,6 +2218,9 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
         }
     }
 
+    assert(!::dstxManager);
+    ::dstxManager = std::make_unique<CDSTXManager>();
+
     assert(!::mmetaman);
     ::mmetaman = std::make_unique<CMasternodeMetaMan>(fLoadCacheFiles);
     if (!::mmetaman->IsValid()) {
diff --git a/src/net.cpp b/src/net.cpp
index 2deec3d9ba18..2777d67abc6a 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3758,7 +3758,7 @@ void CConnman::RelayTransaction(const CTransaction& tx)
 {
     uint256 hash = tx.GetHash();
     int nInv = MSG_TX;
-    if (CoinJoin::GetDSTX(hash)) {
+    if (::dstxManager->GetDSTX(hash)) {
         nInv = MSG_DSTX;
     }
     CInv inv(nInv, hash);
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 797ab8e15c22..cabf064eec70 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1834,7 +1834,7 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
                                         m_llmq_ctx->isman->IsLocked(inv.hash);
 
             return (!fIgnoreRecentRejects && m_recent_rejects.contains(inv.hash)) ||
-                   (inv.type == MSG_DSTX && static_cast<bool>(CoinJoin::GetDSTX(inv.hash))) ||
+                   (inv.type == MSG_DSTX && static_cast<bool>(::dstxManager->GetDSTX(inv.hash))) ||
                    m_mempool.exists(inv.hash) ||
                    (g_txindex != nullptr && g_txindex->HasTx(inv.hash));
         }
@@ -1882,7 +1882,7 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
 
 void PeerManagerImpl::RelayTransaction(const uint256& txid)
 {
-    CInv inv(CoinJoin::GetDSTX(txid) ? MSG_DSTX : MSG_TX, txid);
+    CInv inv(::dstxManager->GetDSTX(txid) ? MSG_DSTX : MSG_TX, txid);
     m_connman.ForEachNode([&inv](CNode* pnode)
     {
         pnode->PushInventory(inv);
@@ -2149,7 +2149,7 @@ void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic
             if (tx) {
                 CCoinJoinBroadcastTx dstx;
                 if (inv.type == MSG_DSTX) {
-                    dstx = CoinJoin::GetDSTX(inv.hash);
+                    dstx = ::dstxManager->GetDSTX(inv.hash);
                 }
                 if (dstx) {
                     m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::DSTX, dstx));
@@ -2731,7 +2731,7 @@ std::pair<bool /*ret*/, bool /*do_return*/> static ValidateDSTX(CTxMemPool& memp
         LogPrint(BCLog::COINJOIN, "DSTX -- Invalid DSTX structure: %s\n", hashTx.ToString());
         return {false, true};
     }
-    if (CoinJoin::GetDSTX(hashTx)) {
+    if (::dstxManager->GetDSTX(hashTx)) {
         LogPrint(BCLog::COINJOIN, "DSTX -- Already have %s, skipping...\n", hashTx.ToString());
         return {true, true}; // not an error
     }
@@ -3589,7 +3589,7 @@ void PeerManagerImpl::ProcessMessage(
             if (nInvType == MSG_DSTX) {
                 LogPrint(BCLog::COINJOIN, "DSTX -- Masternode transaction accepted, txid=%s, peer=%d\n",
                          tx.GetHash().ToString(), pfrom.GetId());
-                CoinJoin::AddDSTX(dstx);
+                ::dstxManager->AddDSTX(dstx);
             }
 
             m_mempool.check(m_chainman.ActiveChainstate());
@@ -4992,7 +4992,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                         pto->m_tx_relay->setInventoryTxToSend.erase(hash);
                         if (pto->m_tx_relay->pfilter && !pto->m_tx_relay->pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
 
-                        int nInvType = CoinJoin::GetDSTX(hash) ? MSG_DSTX : MSG_TX;
+                        int nInvType = ::dstxManager->GetDSTX(hash) ? MSG_DSTX : MSG_TX;
                         queueAndMaybePushInv(CInv(nInvType, hash));
 
                         const auto islock = m_llmq_ctx->isman->GetInstantSendLockByTxid(hash);
@@ -5061,7 +5061,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                                 vRelayExpiration.push_back(std::make_pair(nNow + std::chrono::microseconds{RELAY_TX_CACHE_TIME}.count(), ret.first));
                             }
                         }
-                        int nInvType = CoinJoin::GetDSTX(hash) ? MSG_DSTX : MSG_TX;
+                        int nInvType = ::dstxManager->GetDSTX(hash) ? MSG_DSTX : MSG_TX;
                         queueAndMaybePushInv(CInv(nInvType, hash));
                     }
                 }
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 29bfccd987a7..821b52f574bf 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -214,6 +214,7 @@ ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::ve
     ::sporkManager = std::make_unique<CSporkManager>();
     ::governance = std::make_unique<CGovernanceManager>();
     ::masternodeSync = std::make_unique<CMasternodeSync>(*m_node.connman, *::governance);
+    ::dstxManager = std::make_unique<CDSTXManager>();
     ::mmetaman = std::make_unique<CMasternodeMetaMan>(/* load_cache */ false);
     ::netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(/* load_cache */ false);
 
@@ -237,6 +238,7 @@ ChainTestingSetup::~ChainTestingSetup()
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     ::netfulfilledman.reset();
     ::mmetaman.reset();
+    ::dstxManager.reset();
     ::masternodeSync.reset();
     ::governance.reset();
     ::sporkManager.reset();

From f6f6131524de2f6e5ee1489a9a9f2dadcc9f34e6 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 02:52:13 +0700
Subject: [PATCH 07/22] refactor: moved call
 g_wallet_init_interface.InitCoinJoinSettings inside CJ code

---
 src/coinjoin/client.cpp | 6 ++++++
 src/coinjoin/client.h   | 4 +---
 src/wallet/wallet.cpp   | 3 ---
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 4ba4697fddf4..35d6f9da44af 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -22,6 +22,7 @@
 #include <util/translation.h>
 #include <validation.h>
 #include <version.h>
+#include <walletinitinterface.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 
@@ -1894,6 +1895,7 @@ void CJClientManager::Add(CWallet& wallet) {
         wallet.GetName(),
         std::make_unique<CCoinJoinClientManager>(wallet, *this, m_mn_sync, m_queueman)
     );
+    g_wallet_init_interface.InitCoinJoinSettings(*this);
 }
 
 void CJClientManager::DoMaintenance(CBlockPolicyEstimator& fee_estimator) {
@@ -1901,3 +1903,7 @@ void CJClientManager::DoMaintenance(CBlockPolicyEstimator& fee_estimator) {
         clientman->DoMaintenance(m_connman, fee_estimator, m_mempool);
     }
 }
+void CJClientManager::Remove(const std::string& name) {
+    m_wallet_manager_map.erase(name);
+    g_wallet_init_interface.InitCoinJoinSettings(*this);
+}
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 8d2c883091fa..4f89549c8693 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -86,9 +86,7 @@ class CJClientManager {
     void Add(CWallet& wallet);
     void DoMaintenance(CBlockPolicyEstimator& fee_estimator);
 
-    void Remove(const std::string& name) {
-        m_wallet_manager_map.erase(name);
-    }
+    void Remove(const std::string& name);
 
     CCoinJoinClientManager* Get(const CWallet& wallet) const {
         auto it = m_wallet_manager_map.find(wallet.GetName());
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index bba52ada0885..6644ca9615f6 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -39,7 +39,6 @@
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
 #include <wallet/fees.h>
-#include <walletinitinterface.h>
 #include <warnings.h>
 
 #include <coinjoin/client.h>
@@ -117,7 +116,6 @@ bool AddWallet(const std::shared_ptr<CWallet>& wallet)
     wallet->AutoLockMasternodeCollaterals();
     assert(::masternodeSync != nullptr && ::coinJoinClientManagers != nullptr);
     ::coinJoinClientManagers->Add(*wallet);
-    g_wallet_init_interface.InitCoinJoinSettings(*::coinJoinClientManagers);
     wallet->NotifyCanGetAddressesChanged();
     return true;
 }
@@ -140,7 +138,6 @@ bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> lo
 
     assert(::coinJoinClientManagers != nullptr);
     ::coinJoinClientManagers->Remove(name);
-    g_wallet_init_interface.InitCoinJoinSettings(*::coinJoinClientManagers);
 
     // Write the wallet setting
     UpdateWalletSetting(chain, name, load_on_start, warnings);

From 52153d9849b14cb9e8491886b4aeaf4004520aa2 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 02:53:01 +0700
Subject: [PATCH 08/22] refactor: assert of masternodeSync existance moved from
 wallet to coinjoin

---
 src/coinjoin/client.cpp | 1 +
 src/wallet/wallet.cpp   | 5 ++---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 35d6f9da44af..a8638c7ce34f 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -1891,6 +1891,7 @@ void CCoinJoinClientManager::GetJsonInfo(UniValue& obj) const
 }
 
 void CJClientManager::Add(CWallet& wallet) {
+    assert(::masternodeSync != nullptr);
     m_wallet_manager_map.try_emplace(
         wallet.GetName(),
         std::make_unique<CCoinJoinClientManager>(wallet, *this, m_mn_sync, m_queueman)
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6644ca9615f6..72adbc284012 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -44,7 +44,6 @@
 #include <coinjoin/client.h>
 #include <coinjoin/options.h>
 #include <evo/providertx.h>
-#include <masternode/sync.h>
 
 #include <univalue.h>
 
@@ -114,7 +113,7 @@ bool AddWallet(const std::shared_ptr<CWallet>& wallet)
     }
     wallet->ConnectScriptPubKeyManNotifiers();
     wallet->AutoLockMasternodeCollaterals();
-    assert(::masternodeSync != nullptr && ::coinJoinClientManagers != nullptr);
+    assert(::coinJoinClientManagers != nullptr);
     ::coinJoinClientManagers->Add(*wallet);
     wallet->NotifyCanGetAddressesChanged();
     return true;
@@ -4819,7 +4818,7 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::st
         walletInstance->GetDatabase().IncrementUpdateCounter();
     }
 
-    assert(::masternodeSync != nullptr && ::coinJoinClientManagers != nullptr);
+    assert(::coinJoinClientManagers != nullptr);
     ::coinJoinClientManagers->Add(*walletInstance);
 
     {

From f03570831710780fe48345f590fc2bd5657f97f8 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 03:10:45 +0700
Subject: [PATCH 09/22] refactor: drop global param coinJoinClientManager from
 interfaces::MakeWallet

---
 src/interfaces/wallet.h          | 2 +-
 src/qt/test/addressbooktests.cpp | 4 +---
 src/qt/test/wallettests.cpp      | 4 +---
 src/wallet/interfaces.cpp        | 8 ++++----
 src/wallet/wallet.cpp            | 2 +-
 5 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 92be583100c9..f7361f7e6b0d 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -456,7 +456,7 @@ struct WalletTxOut
 
 //! Return implementation of Wallet interface. This function is defined in
 //! dummywallet.cpp and throws if the wallet component is not compiled.
-std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet, const CJClientManager& clientman);
+std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet);
 
 //! Return implementation of ChainClient interface for a wallet loader. This
 //! function will be undefined in builds where ENABLE_WALLET is false.
diff --git a/src/qt/test/addressbooktests.cpp b/src/qt/test/addressbooktests.cpp
index b5958ba75f95..f646419a6c97 100644
--- a/src/qt/test/addressbooktests.cpp
+++ b/src/qt/test/addressbooktests.cpp
@@ -14,7 +14,6 @@
 #include <qt/qvalidatedlineedit.h>
 #include <qt/walletmodel.h>
 
-#include <coinjoin/client.h>
 #include <key.h>
 #include <key_io.h>
 #include <wallet/wallet.h>
@@ -109,8 +108,7 @@ void TestAddAddressesToSendBook(interfaces::Node& node)
     OptionsModel optionsModel(node);
     ClientModel clientModel(node, &optionsModel);
     AddWallet(wallet);
-    // TODO: replace access of CoinJoin objects with access through interface
-    WalletModel walletModel(interfaces::MakeWallet(wallet, *::coinJoinClientManagers), clientModel);
+    WalletModel walletModel(interfaces::MakeWallet(wallet), clientModel);
     RemoveWallet(wallet, std::nullopt);
     EditAddressDialog editAddressDialog(EditAddressDialog::NewSendingAddress);
     editAddressDialog.setModel(walletModel.getAddressTableModel());
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index deb3b76aa3e1..85c799f88c5a 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -5,7 +5,6 @@
 #include <qt/test/wallettests.h>
 #include <qt/test/util.h>
 
-#include <coinjoin/client.h>
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <qt/bitcoinamountfield.h>
@@ -135,8 +134,7 @@ void TestGUI(interfaces::Node& node)
     TransactionView transactionView;
     OptionsModel optionsModel(node);
     ClientModel clientModel(node, &optionsModel);
-    // TODO: replace access of CoinJoin objects with access through interface
-    WalletModel walletModel(interfaces::MakeWallet(wallet, *::coinJoinClientManagers), clientModel);;
+    WalletModel walletModel(interfaces::MakeWallet(wallet), clientModel);
     sendCoinsDialog.setModel(&walletModel);
     transactionView.setModel(&walletModel);
 
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index ffdd819071a2..bdbe7935df30 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -639,14 +639,14 @@ class WalletLoaderImpl : public WalletLoader
         options.require_create = true;
         options.create_flags = wallet_creation_flags;
         options.create_passphrase = passphrase;
-        return MakeWallet(CreateWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings), client_man);
+        return MakeWallet(CreateWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings));
     }
     std::unique_ptr<Wallet> loadWallet(const CJClientManager& client_man, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) override
     {
         DatabaseOptions options;
         DatabaseStatus status;
         options.require_existing = true;
-        return MakeWallet(LoadWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings), client_man);
+        return MakeWallet(LoadWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings));
     }
     std::string getWalletDir() override
     {
@@ -664,7 +664,7 @@ class WalletLoaderImpl : public WalletLoader
     {
         std::vector<std::unique_ptr<Wallet>> wallets;
         for (const auto& wallet : GetWallets()) {
-            wallets.emplace_back(MakeWallet(wallet, *::coinJoinClientManagers));
+            wallets.emplace_back(MakeWallet(wallet));
         }
         return wallets;
     }
@@ -682,7 +682,7 @@ class WalletLoaderImpl : public WalletLoader
 } // namespace wallet
 
 namespace interfaces {
-std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet, const CJClientManager& clientman) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, clientman) : nullptr; }
+std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, *::coinJoinClientManagers) : nullptr; }
 std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, ArgsManager& args) {
     return std::make_unique<wallet::WalletLoaderImpl>(chain, args);
 }
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 72adbc284012..752caccac4e2 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -4824,7 +4824,7 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::st
     {
         LOCK(cs_wallets);
         for (auto& load_wallet : g_load_wallet_fns) {
-            load_wallet(interfaces::MakeWallet(walletInstance, *::coinJoinClientManagers));
+            load_wallet(interfaces::MakeWallet(walletInstance));
         }
     }
 

From b208e911c6a16ad92418ffd294e44912568f3b3f Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Sun, 31 Dec 2023 14:30:53 +0300
Subject: [PATCH 10/22] refactor: rename CJClientManager

---
 src/coinjoin/client.cpp            | 24 +++++++++++-----------
 src/coinjoin/client.h              | 26 ++++++++++++------------
 src/coinjoin/context.cpp           | 14 ++++++-------
 src/coinjoin/context.h             |  4 ++--
 src/dsnotificationinterface.cpp    |  2 +-
 src/dummywallet.cpp                |  4 ++--
 src/init.cpp                       |  4 ++--
 src/interfaces/wallet.h            |  6 +++---
 src/masternode/utils.cpp           |  2 +-
 src/net_processing.cpp             |  2 +-
 src/qt/walletcontroller.cpp        |  4 ++--
 src/rpc/coinjoin.cpp               |  4 ++--
 src/wallet/init.cpp                |  6 +++---
 src/wallet/interfaces.cpp          | 32 +++++++++++++++---------------
 src/wallet/load.cpp                |  2 +-
 src/wallet/test/coinjoin_tests.cpp |  4 ++--
 src/wallet/wallet.cpp              | 16 +++++++--------
 src/walletinitinterface.h          |  4 ++--
 18 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index a8638c7ce34f..083b8410775f 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -29,7 +29,7 @@
 #include <memory>
 #include <univalue.h>
 
-std::unique_ptr<CJClientManager> coinJoinClientManagers;
+std::unique_ptr<CoinJoinWalletManager> coinJoinWalletManager;
 
 void CCoinJoinClientQueueManager::ProcessMessage(const CNode& peer, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv)
 {
@@ -99,7 +99,7 @@ void CCoinJoinClientQueueManager::ProcessDSQueue(const CNode& peer, PeerManager&
         }
 
         // if the queue is ready, submit if we can
-        if (dsq.fReady && ranges::any_of(m_clientman.raw(),
+        if (dsq.fReady && ranges::any_of(m_walletman.raw(),
                                          [this, &dmn](const auto &pair) {
                                              return pair.second->TrySubmitDenominate(dmn->pdmnState->addr,
                                                                                      this->connman);
@@ -124,7 +124,7 @@ void CCoinJoinClientQueueManager::ProcessDSQueue(const CNode& peer, PeerManager&
             LogPrint(BCLog::COINJOIN, "DSQUEUE -- new CoinJoin queue (%s) from masternode %s\n", dsq.ToString(),
                      dmn->pdmnState->addr.ToString());
 
-            ranges::any_of(m_clientman.raw(),
+            ranges::any_of(m_walletman.raw(),
                            [&dsq](const auto &pair) { return pair.second->MarkAlreadyJoinedQueueAsTried(dsq); });
 
             WITH_LOCK(cs_vecqueue, vecCoinJoinQueue.push_back(dsq));
@@ -157,11 +157,11 @@ void CCoinJoinClientManager::ProcessMessage(CNode& peer, PeerManager& peerman, C
     }
 }
 
-CCoinJoinClientSession::CCoinJoinClientSession(CWallet& pwallet, CJClientManager& clientman, const CMasternodeSync& mn_sync,
+CCoinJoinClientSession::CCoinJoinClientSession(CWallet& pwallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
                                                const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
     m_wallet(pwallet),
-    m_clientman(clientman),
-    m_manager(*Assert(clientman.Get(pwallet))),
+    m_walletman(walletman),
+    m_manager(*Assert(walletman.Get(pwallet))),
     m_mn_sync(mn_sync),
     m_queueman(queueman)
 {}
@@ -991,7 +991,7 @@ bool CCoinJoinClientManager::DoAutomaticDenominating(CConnman& connman, CBlockPo
     AssertLockNotHeld(cs_deqsessions);
     LOCK(cs_deqsessions);
     if (int(deqSessions.size()) < CCoinJoinClientOptions::GetSessions()) {
-        deqSessions.emplace_back(m_wallet, m_clientman, m_mn_sync, m_queueman);
+        deqSessions.emplace_back(m_wallet, m_walletman, m_mn_sync, m_queueman);
     }
     for (auto& session : deqSessions) {
         if (!CheckAutomaticBackup()) return false;
@@ -1890,7 +1890,7 @@ void CCoinJoinClientManager::GetJsonInfo(UniValue& obj) const
     obj.pushKV("sessions",  arrSessions);
 }
 
-void CJClientManager::Add(CWallet& wallet) {
+void CoinJoinWalletManager::Add(CWallet& wallet) {
     assert(::masternodeSync != nullptr);
     m_wallet_manager_map.try_emplace(
         wallet.GetName(),
@@ -1899,12 +1899,12 @@ void CJClientManager::Add(CWallet& wallet) {
     g_wallet_init_interface.InitCoinJoinSettings(*this);
 }
 
-void CJClientManager::DoMaintenance(CBlockPolicyEstimator& fee_estimator) {
-    for (auto& [wallet_str, clientman] : m_wallet_manager_map) {
-        clientman->DoMaintenance(m_connman, fee_estimator, m_mempool);
+void CoinJoinWalletManager::DoMaintenance(CBlockPolicyEstimator& fee_estimator) {
+    for (auto& [wallet_str, walletman] : m_wallet_manager_map) {
+        walletman->DoMaintenance(m_connman, fee_estimator, m_mempool);
     }
 }
-void CJClientManager::Remove(const std::string& name) {
+void CoinJoinWalletManager::Remove(const std::string& name) {
     m_wallet_manager_map.erase(name);
     g_wallet_init_interface.InitCoinJoinSettings(*this);
 }
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 4f89549c8693..7600a1dced29 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -19,7 +19,7 @@ class CCoinJoinClientManager;
 class CCoinJoinClientQueueManager;
 class CConnman;
 class CDeterministicMN;
-class CJClientManager;
+class CoinJoinWalletManager;
 class CNode;
 class CMasternodeSync;
 class CTxMemPool;
@@ -30,7 +30,7 @@ class UniValue;
 using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
 
 // The main object for accessing mixing
-extern std::unique_ptr<CJClientManager> coinJoinClientManagers;
+extern std::unique_ptr<CoinJoinWalletManager> coinJoinWalletManager;
 
 class CPendingDsaRequest
 {
@@ -69,15 +69,15 @@ class CPendingDsaRequest
     }
 };
 
-class CJClientManager {
+class CoinJoinWalletManager {
 public:
     using wallet_name_cjman_map = std::map<const std::string, std::unique_ptr<CCoinJoinClientManager>>;
 
 public:
-    CJClientManager(CConnman& connman, CTxMemPool& mempool, const CMasternodeSync& mn_sync,
+    CoinJoinWalletManager(CConnman& connman, CTxMemPool& mempool, const CMasternodeSync& mn_sync,
                     const std::unique_ptr<CCoinJoinClientQueueManager>& queueman)
         : m_connman(connman), m_mempool(mempool), m_mn_sync(mn_sync), m_queueman(queueman) {}
-    ~CJClientManager() {
+    ~CoinJoinWalletManager() {
         for (auto& [wallet_name, cj_man] : m_wallet_manager_map) {
             cj_man.reset();
         }
@@ -109,7 +109,7 @@ class CCoinJoinClientSession : public CCoinJoinBaseSession
 {
 private:
     CWallet& m_wallet;
-    CJClientManager& m_clientman;
+    CoinJoinWalletManager& m_walletman;
     CCoinJoinClientManager& m_manager;
 
     const CMasternodeSync& m_mn_sync;
@@ -161,7 +161,7 @@ class CCoinJoinClientSession : public CCoinJoinBaseSession
     void SetNull() EXCLUSIVE_LOCKS_REQUIRED(cs_coinjoin);
 
 public:
-    explicit CCoinJoinClientSession(CWallet& pwallet, CJClientManager& clientman, const CMasternodeSync& mn_sync,
+    explicit CCoinJoinClientSession(CWallet& pwallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
                                     const std::unique_ptr<CCoinJoinClientQueueManager>& queueman);
 
     void ProcessMessage(CNode& peer, PeerManager& peerman, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv);
@@ -193,13 +193,13 @@ class CCoinJoinClientQueueManager : public CCoinJoinBaseManager
 {
 private:
     CConnman& connman;
-    CJClientManager& m_clientman;
+    CoinJoinWalletManager& m_walletman;
     const CMasternodeSync& m_mn_sync;
     mutable Mutex cs_ProcessDSQueue;
 
 public:
-    explicit CCoinJoinClientQueueManager(CConnman& _connman, CJClientManager& clientman, const CMasternodeSync& mn_sync) :
-        connman(_connman), m_clientman(clientman), m_mn_sync(mn_sync) {};
+    explicit CCoinJoinClientQueueManager(CConnman& _connman, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync) :
+        connman(_connman), m_walletman(walletman), m_mn_sync(mn_sync) {};
 
     void ProcessMessage(const CNode& peer, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv) LOCKS_EXCLUDED(cs_vecqueue);
     void ProcessDSQueue(const CNode& peer, PeerManager& peerman, CDataStream& vRecv);
@@ -212,7 +212,7 @@ class CCoinJoinClientManager
 {
 private:
     CWallet& m_wallet;
-    CJClientManager& m_clientman;
+    CoinJoinWalletManager& m_walletman;
 
     const CMasternodeSync& m_mn_sync;
     const std::unique_ptr<CCoinJoinClientQueueManager>& m_queueman;
@@ -246,9 +246,9 @@ class CCoinJoinClientManager
     CCoinJoinClientManager(CCoinJoinClientManager const&) = delete;
     CCoinJoinClientManager& operator=(CCoinJoinClientManager const&) = delete;
 
-    explicit CCoinJoinClientManager(CWallet& wallet, CJClientManager& clientman, const CMasternodeSync& mn_sync,
+    explicit CCoinJoinClientManager(CWallet& wallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
                                     const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
-        m_wallet(wallet), m_clientman(clientman), m_mn_sync(mn_sync), m_queueman(queueman) {}
+        m_wallet(wallet), m_walletman(walletman), m_mn_sync(mn_sync), m_queueman(queueman) {}
 
     void ProcessMessage(CNode& peer, PeerManager& peerman, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv) LOCKS_EXCLUDED(cs_deqsessions);
 
diff --git a/src/coinjoin/context.cpp b/src/coinjoin/context.cpp
index 4e8c7253208c..294cbb1f7e58 100644
--- a/src/coinjoin/context.cpp
+++ b/src/coinjoin/context.cpp
@@ -15,20 +15,20 @@
 
 CJContext::CJContext(CChainState& chainstate, CConnman& connman, CTxMemPool& mempool, const CMasternodeSync& mn_sync, bool relay_txes) :
 #ifdef ENABLE_WALLET
-    clientman {
-        [&]() -> CJClientManager* const {
-            assert(::coinJoinClientManagers == nullptr);
-            ::coinJoinClientManagers = std::make_unique<CJClientManager>(connman, mempool, mn_sync, queueman);
-            return ::coinJoinClientManagers.get();
+    walletman {
+        [&]() -> CoinJoinWalletManager* const {
+            assert(::coinJoinWalletManager == nullptr);
+            ::coinJoinWalletManager = std::make_unique<CoinJoinWalletManager>(connman, mempool, mn_sync, queueman);
+            return ::coinJoinWalletManager.get();
         }()
     },
-    queueman {relay_txes ? std::make_unique<CCoinJoinClientQueueManager>(connman, *clientman, mn_sync) : nullptr},
+    queueman {relay_txes ? std::make_unique<CCoinJoinClientQueueManager>(connman, *walletman, mn_sync) : nullptr},
 #endif // ENABLE_WALLET
     server{std::make_unique<CCoinJoinServer>(chainstate, connman, mempool, mn_sync)}
 {}
 
 CJContext::~CJContext() {
 #ifdef ENABLE_WALLET
-    ::coinJoinClientManagers.reset();
+    ::coinJoinWalletManager.reset();
 #endif // ENABLE_WALLET
 }
diff --git a/src/coinjoin/context.h b/src/coinjoin/context.h
index d05da33e3c7c..7f2fc4f79bf1 100644
--- a/src/coinjoin/context.h
+++ b/src/coinjoin/context.h
@@ -20,7 +20,7 @@ class CTxMemPool;
 
 #ifdef ENABLE_WALLET
 class CCoinJoinClientQueueManager;
-class CJClientManager;
+class CoinJoinWalletManager;
 #endif // ENABLE_WALLET
 
 struct CJContext {
@@ -30,7 +30,7 @@ struct CJContext {
     ~CJContext();
 
 #ifdef ENABLE_WALLET
-    CJClientManager* const clientman;
+    CoinJoinWalletManager* const walletman;
     const std::unique_ptr<CCoinJoinClientQueueManager> queueman;
 #endif // ENABLE_WALLET
     const std::unique_ptr<CCoinJoinServer> server;
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index ca28e605a75c..f821607c9af1 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -69,7 +69,7 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
 
     ::dstxManager->UpdatedBlockTip(pindexNew, *llmq_ctx->clhandler, m_mn_sync);
 #ifdef ENABLE_WALLET
-    for (auto& pair : cj_ctx->clientman->raw()) {
+    for (auto& pair : cj_ctx->walletman->raw()) {
         pair.second->UpdatedBlockTip(pindexNew);
     }
 #endif // ENABLE_WALLET
diff --git a/src/dummywallet.cpp b/src/dummywallet.cpp
index ae088b36c4a4..6bd92a5f25b7 100644
--- a/src/dummywallet.cpp
+++ b/src/dummywallet.cpp
@@ -24,7 +24,7 @@ class DummyWalletInit : public WalletInitInterface {
 
     // Dash Specific WalletInitInterface InitCoinJoinSettings
     void AutoLockMasternodeCollaterals() const override {}
-    void InitCoinJoinSettings(const CJClientManager& clientman) const override {}
+    void InitCoinJoinSettings(const CoinJoinWalletManager& cjwalletman) const override {}
     bool InitAutoBackup() const override {return true;}
 };
 
@@ -74,7 +74,7 @@ const WalletInitInterface& g_wallet_init_interface = DummyWalletInit();
 
 namespace interfaces {
 
-std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet, const CJClientManager& clientman)
+std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet, const CoinJoinWalletManager& cjwalletman)
 {
     throw std::logic_error("Wallet function called in non-wallet build.");
 }
diff --git a/src/init.cpp b/src/init.cpp
index 1a6fd61fccc3..e874f0a8f95f 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -2201,7 +2201,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.mempool, *::masternodeSync, !ignores_incoming_txs);
 
 #ifdef ENABLE_WALLET
-    g_wallet_init_interface.InitCoinJoinSettings(*node.cj_ctx->clientman);
+    g_wallet_init_interface.InitCoinJoinSettings(*node.cj_ctx->walletman);
 #endif // ENABLE_WALLET
 
     // ********************************************************* Step 7d: Setup other Dash services
@@ -2319,7 +2319,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 #ifdef ENABLE_WALLET
     } else if (!ignores_incoming_txs) {
         node.scheduler->scheduleEvery(std::bind(&CCoinJoinClientQueueManager::DoMaintenance, std::ref(*node.cj_ctx->queueman)), std::chrono::seconds{1});
-        node.scheduler->scheduleEvery(std::bind(&CJClientManager::DoMaintenance, std::ref(*node.cj_ctx->clientman), std::ref(*node.fee_estimator)), std::chrono::seconds{1});
+        node.scheduler->scheduleEvery(std::bind(&CoinJoinWalletManager::DoMaintenance, std::ref(*node.cj_ctx->walletman), std::ref(*node.fee_estimator)), std::chrono::seconds{1});
 #endif // ENABLE_WALLET
     }
 
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index f7361f7e6b0d..b46cdc5e9f83 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -26,7 +26,7 @@
 
 class CCoinControl;
 class CFeeRate;
-class CJClientManager;
+class CoinJoinWalletManager;
 class CKey;
 class CWallet;
 class UniValue;
@@ -355,10 +355,10 @@ class WalletLoader : public ChainClient
 {
 public:
     //! Create new wallet.
-    virtual std::unique_ptr<Wallet> createWallet(const CJClientManager& client_man, const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
+    virtual std::unique_ptr<Wallet> createWallet(const CoinJoinWalletManager& cjwalletman, const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
 
    //! Load existing wallet.
-   virtual std::unique_ptr<Wallet> loadWallet(const CJClientManager& client_man, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
+   virtual std::unique_ptr<Wallet> loadWallet(const CoinJoinWalletManager& cjwalletman, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
 
    //! Return default wallet directory.
    virtual std::string getWalletDir() = 0;
diff --git a/src/masternode/utils.cpp b/src/masternode/utils.cpp
index 88c053c1870b..9cc6341dff46 100644
--- a/src/masternode/utils.cpp
+++ b/src/masternode/utils.cpp
@@ -22,7 +22,7 @@ void CMasternodeUtils::DoMaintenance(CConnman& connman, const CMasternodeSync& m
 
     std::vector<CDeterministicMNCPtr> vecDmns; // will be empty when no wallet
 #ifdef ENABLE_WALLET
-    for (auto& pair : cj_ctx.clientman->raw()) {
+    for (auto& pair : cj_ctx.walletman->raw()) {
         pair.second->GetMixingMasternodesInfo(vecDmns);
     }
 #endif // ENABLE_WALLET
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index cabf064eec70..9f26003ead82 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -4334,7 +4334,7 @@ void PeerManagerImpl::ProcessMessage(
         //probably one the extensions
 #ifdef ENABLE_WALLET
         m_cj_ctx->queueman->ProcessMessage(pfrom, *this, msg_type, vRecv);
-        for (auto& pair : m_cj_ctx->clientman->raw()) {
+        for (auto& pair : m_cj_ctx->walletman->raw()) {
             pair.second->ProcessMessage(pfrom, *this, m_connman, m_mempool, msg_type, vRecv);
         }
 #endif // ENABLE_WALLET
diff --git a/src/qt/walletcontroller.cpp b/src/qt/walletcontroller.cpp
index c49989e7fc47..d34b75756ff4 100644
--- a/src/qt/walletcontroller.cpp
+++ b/src/qt/walletcontroller.cpp
@@ -250,7 +250,7 @@ void CreateWalletActivity::createWallet()
     }
 
     QTimer::singleShot(500, worker(), [this, name, flags] {
-        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().createWallet(*::coinJoinClientManagers, name, m_passphrase, flags, m_error_message, m_warning_message);
+        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().createWallet(*::coinJoinWalletManager, name, m_passphrase, flags, m_error_message, m_warning_message);
 
         if (wallet) m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(wallet));
 
@@ -321,7 +321,7 @@ void OpenWalletActivity::open(const std::string& path)
     showProgressDialog(tr("Opening Wallet <b>%1</b>...").arg(name.toHtmlEscaped()));
 
     QTimer::singleShot(0, worker(), [this, path] {
-        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().loadWallet(*::coinJoinClientManagers, path, m_error_message, m_warning_message);
+        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().loadWallet(*::coinJoinWalletManager, path, m_error_message, m_warning_message);
 
         if (wallet) m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(wallet));
 
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index 2dd16529eb52..aeeb8f8d83d0 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -51,7 +51,7 @@ static UniValue coinjoin(const JSONRPCRequest& request)
         }
     }
 
-    auto cj_clientman = ::coinJoinClientManagers->Get(*wallet);
+    auto cj_clientman = ::coinJoinWalletManager->Get(*wallet);
     CHECK_NONFATAL(cj_clientman != nullptr);
 
     if (request.params[0].get_str() == "start") {
@@ -163,7 +163,7 @@ static UniValue getcoinjoininfo(const JSONRPCRequest& request)
         return obj;
     }
 
-    auto manager = ::coinJoinClientManagers->Get(*wallet);
+    auto manager = ::coinJoinWalletManager->Get(*wallet);
     CHECK_NONFATAL(manager != nullptr);
     manager->GetJsonInfo(obj);
 
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index b0bb48e8e7bf..91f57d85099d 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -46,7 +46,7 @@ class WalletInit : public WalletInitInterface
 
     // Dash Specific Wallet Init
     void AutoLockMasternodeCollaterals() const override;
-    void InitCoinJoinSettings(const CJClientManager& clientman) const override;
+    void InitCoinJoinSettings(const CoinJoinWalletManager& cjwalletman) const override;
     bool InitAutoBackup() const override;
 };
 
@@ -199,7 +199,7 @@ void WalletInit::AutoLockMasternodeCollaterals() const
     }
 }
 
-void WalletInit::InitCoinJoinSettings(const CJClientManager& clientman) const
+void WalletInit::InitCoinJoinSettings(const CoinJoinWalletManager& cjwalletman) const
 {
     CCoinJoinClientOptions::SetEnabled(!GetWallets().empty() ? gArgs.GetBoolArg("-enablecoinjoin", true) : false);
     if (!CCoinJoinClientOptions::IsEnabled()) {
@@ -207,7 +207,7 @@ void WalletInit::InitCoinJoinSettings(const CJClientManager& clientman) const
     }
     bool fAutoStart = gArgs.GetBoolArg("-coinjoinautostart", DEFAULT_COINJOIN_AUTOSTART);
     for (auto& pwallet : GetWallets()) {
-        auto manager = clientman.Get(*pwallet);
+        auto manager = cjwalletman.Get(*pwallet);
         assert(manager != nullptr);
         if (pwallet->IsLocked()) {
             manager->StopMixing();
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index bdbe7935df30..29f3676d5cc5 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -123,54 +123,54 @@ WalletTxOut MakeWalletTxOut(const CWallet& wallet,
 namespace CoinJoin = interfaces::CoinJoin;
 class CoinJoinImpl : public CoinJoin::Client
 {
-    CCoinJoinClientManager& m_manager;
+    CCoinJoinClientManager& m_clientman;
 
 public:
-    CoinJoinImpl(const CJClientManager& clientman, const std::shared_ptr<CWallet>& wallet)
-        : m_manager(*Assert(clientman.Get(*wallet))) {}
+    CoinJoinImpl(const CoinJoinWalletManager& walletman, const std::shared_ptr<CWallet>& wallet)
+        : m_clientman(*Assert(walletman.Get(*wallet))) {}
 
     void resetCachedBlocks() override
     {
-        m_manager.nCachedNumBlocks = std::numeric_limits<int>::max();
+        m_clientman.nCachedNumBlocks = std::numeric_limits<int>::max();
     }
     void resetPool() override
     {
-        m_manager.ResetPool();
+        m_clientman.ResetPool();
     }
     void disableAutobackups() override
     {
-        m_manager.fCreateAutoBackups = false;
+        m_clientman.fCreateAutoBackups = false;
     }
     int getCachedBlocks() override
     {
-        return m_manager.nCachedNumBlocks;
+        return m_clientman.nCachedNumBlocks;
     }
     std::string getSessionDenoms() override
     {
-        return m_manager.GetSessionDenoms();
+        return m_clientman.GetSessionDenoms();
     }
     void setCachedBlocks(int nCachedBlocks) override
     {
-       m_manager.nCachedNumBlocks = nCachedBlocks;
+       m_clientman.nCachedNumBlocks = nCachedBlocks;
     }
     bool isMixing() override
     {
-        return m_manager.IsMixing();
+        return m_clientman.IsMixing();
     }
     bool startMixing() override
     {
-        return m_manager.StartMixing();
+        return m_clientman.StartMixing();
     }
     void stopMixing() override
     {
-        m_manager.StopMixing();
+        m_clientman.StopMixing();
     }
 };
 
 class WalletImpl : public Wallet
 {
 public:
-    explicit WalletImpl(const std::shared_ptr<CWallet>& wallet, const CJClientManager& clientman) : m_wallet(wallet), m_coinjoin(clientman, wallet) {}
+    explicit WalletImpl(const std::shared_ptr<CWallet>& wallet, CoinJoinWalletManager& cjwalletman) : m_wallet(wallet), m_coinjoin(cjwalletman, wallet) {}
 
     void markDirty() override
     {
@@ -631,7 +631,7 @@ class WalletLoaderImpl : public WalletLoader
     void setMockTime(int64_t time) override { return SetMockTime(time); }
 
     //! WalletLoader methods
-    std::unique_ptr<Wallet> createWallet(const CJClientManager& client_man, const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) override
+    std::unique_ptr<Wallet> createWallet(const CoinJoinWalletManager& client_man, const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) override
     {
         std::shared_ptr<CWallet> wallet;
         DatabaseOptions options;
@@ -641,7 +641,7 @@ class WalletLoaderImpl : public WalletLoader
         options.create_passphrase = passphrase;
         return MakeWallet(CreateWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings));
     }
-    std::unique_ptr<Wallet> loadWallet(const CJClientManager& client_man, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) override
+    std::unique_ptr<Wallet> loadWallet(const CoinJoinWalletManager& client_man, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) override
     {
         DatabaseOptions options;
         DatabaseStatus status;
@@ -682,7 +682,7 @@ class WalletLoaderImpl : public WalletLoader
 } // namespace wallet
 
 namespace interfaces {
-std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, *::coinJoinClientManagers) : nullptr; }
+std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, *::coinJoinWalletManager) : nullptr; }
 std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, ArgsManager& args) {
     return std::make_unique<wallet::WalletLoaderImpl>(chain, args);
 }
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 1323b781c14e..791a37f6b65e 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -141,7 +141,7 @@ void FlushWallets()
     for (const std::shared_ptr<CWallet>& pwallet : GetWallets()) {
         if (CCoinJoinClientOptions::IsEnabled()) {
             // Stop CoinJoin, release keys
-            auto cj_clientman = ::coinJoinClientManagers->Get(*pwallet);
+            auto cj_clientman = ::coinJoinWalletManager->Get(*pwallet);
             assert(cj_clientman != nullptr);
             cj_clientman->ResetPool();
             cj_clientman->StopMixing();
diff --git a/src/wallet/test/coinjoin_tests.cpp b/src/wallet/test/coinjoin_tests.cpp
index 387ccd89be2f..f20200dea3e7 100644
--- a/src/wallet/test/coinjoin_tests.cpp
+++ b/src/wallet/test/coinjoin_tests.cpp
@@ -207,8 +207,8 @@ class CTransactionBuilderTestSetup : public TestChain100Setup
 
 BOOST_FIXTURE_TEST_CASE(coinjoin_manager_start_stop_tests, CTransactionBuilderTestSetup)
 {
-    BOOST_CHECK_EQUAL(::coinJoinClientManagers->raw().size(), 1);
-    auto& cj_man = ::coinJoinClientManagers->raw().begin()->second;
+    BOOST_CHECK_EQUAL(::coinJoinWalletManager->raw().size(), 1);
+    auto& cj_man = ::coinJoinWalletManager->raw().begin()->second;
     BOOST_CHECK_EQUAL(cj_man->IsMixing(), false);
     BOOST_CHECK_EQUAL(cj_man->StartMixing(), true);
     BOOST_CHECK_EQUAL(cj_man->IsMixing(), true);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 752caccac4e2..001846742bbb 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -113,8 +113,8 @@ bool AddWallet(const std::shared_ptr<CWallet>& wallet)
     }
     wallet->ConnectScriptPubKeyManNotifiers();
     wallet->AutoLockMasternodeCollaterals();
-    assert(::coinJoinClientManagers != nullptr);
-    ::coinJoinClientManagers->Add(*wallet);
+    assert(::coinJoinWalletManager != nullptr);
+    ::coinJoinWalletManager->Add(*wallet);
     wallet->NotifyCanGetAddressesChanged();
     return true;
 }
@@ -135,8 +135,8 @@ bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> lo
         vpwallets.erase(i);
     }
 
-    assert(::coinJoinClientManagers != nullptr);
-    ::coinJoinClientManagers->Remove(name);
+    assert(::coinJoinWalletManager != nullptr);
+    ::coinJoinWalletManager->Remove(name);
 
     // Write the wallet setting
     UpdateWalletSetting(chain, name, load_on_start, warnings);
@@ -1632,8 +1632,8 @@ void CWallet::UnsetBlankWalletFlag(WalletBatch& batch)
 
 void CWallet::NewKeyPoolCallback()
 {
-    assert(::coinJoinClientManagers != nullptr);
-    auto cj_clientman = ::coinJoinClientManagers->Get(*this);
+    assert(::coinJoinWalletManager != nullptr);
+    auto cj_clientman = ::coinJoinWalletManager->Get(*this);
     if (cj_clientman != nullptr) cj_clientman->StopMixing();
     nKeysLeftSinceAutoBackup = 0;
 }
@@ -4818,8 +4818,8 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::st
         walletInstance->GetDatabase().IncrementUpdateCounter();
     }
 
-    assert(::coinJoinClientManagers != nullptr);
-    ::coinJoinClientManagers->Add(*walletInstance);
+    assert(::coinJoinWalletManager != nullptr);
+    ::coinJoinWalletManager->Add(*walletInstance);
 
     {
         LOCK(cs_wallets);
diff --git a/src/walletinitinterface.h b/src/walletinitinterface.h
index 5a27aa7412fc..6c066f3efd74 100644
--- a/src/walletinitinterface.h
+++ b/src/walletinitinterface.h
@@ -6,7 +6,7 @@
 #define BITCOIN_WALLETINITINTERFACE_H
 
 class ArgsManager;
-class CJClientManager;
+class CoinJoinWalletManager;
 
 struct NodeContext;
 
@@ -23,7 +23,7 @@ class WalletInitInterface {
 
     // Dash Specific WalletInitInterface
     virtual void AutoLockMasternodeCollaterals() const = 0;
-    virtual void InitCoinJoinSettings(const CJClientManager& clientman) const = 0;
+    virtual void InitCoinJoinSettings(const CoinJoinWalletManager& cjwalletman) const = 0;
     virtual bool InitAutoBackup() const = 0;
 
     virtual ~WalletInitInterface() {}

From 1fb184d92750f5ca1b1690e9f49554ba40c108b4 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Sun, 31 Dec 2023 15:44:46 +0300
Subject: [PATCH 11/22] refactor: introduce and use CoinJoin::Loader interface

---
 src/bench/coin_selection.cpp              |  4 +-
 src/bench/wallet_balance.cpp              |  2 +-
 src/init.cpp                              |  1 +
 src/interfaces/wallet.h                   | 19 +++++--
 src/node/context.cpp                      |  1 +
 src/node/context.h                        |  4 ++
 src/qt/test/addressbooktests.cpp          |  2 +-
 src/qt/test/wallettests.cpp               |  2 +-
 src/qt/walletcontroller.cpp               |  4 +-
 src/test/util/setup_common.cpp            |  3 ++
 src/wallet/context.cpp                    |  4 +-
 src/wallet/context.h                      |  8 ++-
 src/wallet/init.cpp                       |  2 +-
 src/wallet/interfaces.cpp                 | 64 ++++++++++++++++++-----
 src/wallet/load.cpp                       |  4 +-
 src/wallet/load.h                         |  6 ++-
 src/wallet/rpcwallet.cpp                  |  4 +-
 src/wallet/salvage.cpp                    |  2 +-
 src/wallet/test/coinjoin_tests.cpp        |  2 +-
 src/wallet/test/coinselector_tests.cpp    |  4 +-
 src/wallet/test/init_test_fixture.cpp     |  2 +-
 src/wallet/test/init_test_fixture.h       |  1 +
 src/wallet/test/ismine_tests.cpp          | 20 +++----
 src/wallet/test/scriptpubkeyman_tests.cpp |  2 +-
 src/wallet/test/wallet_test_fixture.cpp   |  4 +-
 src/wallet/test/wallet_tests.cpp          | 40 +++++++-------
 src/wallet/wallet.cpp                     | 36 ++++++-------
 src/wallet/wallet.h                       | 16 ++++--
 src/wallet/wallettool.cpp                 |  2 +-
 29 files changed, 174 insertions(+), 91 deletions(-)

diff --git a/src/bench/coin_selection.cpp b/src/bench/coin_selection.cpp
index 3d379efd078b..05709f4b4a19 100644
--- a/src/bench/coin_selection.cpp
+++ b/src/bench/coin_selection.cpp
@@ -31,7 +31,7 @@ static void CoinSelection(benchmark::Bench& bench)
 {
     NodeContext node;
     auto chain = interfaces::MakeChain(node);
-    CWallet wallet(chain.get(), "", CreateDummyWalletDatabase());
+    CWallet wallet(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
     wallet.SetupLegacyScriptPubKeyMan();
     std::vector<std::unique_ptr<CWalletTx>> wtxs;
     LOCK(wallet.cs_wallet);
@@ -64,7 +64,7 @@ static void CoinSelection(benchmark::Bench& bench)
 typedef std::set<CInputCoin> CoinSet;
 static NodeContext testNode;
 static auto testChain = interfaces::MakeChain(testNode);
-static CWallet testWallet(testChain.get(), "", CreateDummyWalletDatabase());
+static CWallet testWallet(testChain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
 std::vector<std::unique_ptr<CWalletTx>> wtxn;
 
 // Copied from src/wallet/test/coinselector_tests.cpp
diff --git a/src/bench/wallet_balance.cpp b/src/bench/wallet_balance.cpp
index b8c81a293f2c..be9964cd1cc3 100644
--- a/src/bench/wallet_balance.cpp
+++ b/src/bench/wallet_balance.cpp
@@ -24,7 +24,7 @@ static void WalletBalance(benchmark::Bench& bench, const bool set_dirty, const b
     };
     const auto& ADDRESS_WATCHONLY = ADDRESS_B58T_UNSPENDABLE;
 
-    CWallet wallet{test_setup.m_node.chain.get(), "", CreateMockWalletDatabase()};
+    CWallet wallet{test_setup.m_node.chain.get(), test_setup.m_node.coinjoin_loader, "", CreateMockWalletDatabase()};
     {
         wallet.SetupLegacyScriptPubKeyMan();
         bool first_run;
diff --git a/src/init.cpp b/src/init.cpp
index e874f0a8f95f..52cb928194db 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -2201,6 +2201,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.mempool, *::masternodeSync, !ignores_incoming_txs);
 
 #ifdef ENABLE_WALLET
+    node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*node.cj_ctx->walletman);
     g_wallet_init_interface.InitCoinJoinSettings(*node.cj_ctx->walletman);
 #endif // ENABLE_WALLET
 
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index b46cdc5e9f83..dfe456a24adb 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -68,6 +68,16 @@ class Client
     virtual bool startMixing() = 0;
     virtual void stopMixing() = 0;
 };
+class Loader
+{
+public:
+    virtual ~Loader() {}
+    //! Add new wallet to CoinJoin client manager
+    virtual void AddWallet(CWallet&) = 0;
+    //! Remove wallet from CoinJoin client manager
+    virtual void RemoveWallet(const std::string&) = 0;
+    virtual std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) = 0;
+};
 }
 
 //! Interface for accessing a wallet.
@@ -355,10 +365,10 @@ class WalletLoader : public ChainClient
 {
 public:
     //! Create new wallet.
-    virtual std::unique_ptr<Wallet> createWallet(const CoinJoinWalletManager& cjwalletman, const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
+    virtual std::unique_ptr<Wallet> createWallet(const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
 
    //! Load existing wallet.
-   virtual std::unique_ptr<Wallet> loadWallet(const CoinJoinWalletManager& cjwalletman, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
+   virtual std::unique_ptr<Wallet> loadWallet(const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) = 0;
 
    //! Return default wallet directory.
    virtual std::string getWalletDir() = 0;
@@ -460,7 +470,10 @@ std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet);
 
 //! Return implementation of ChainClient interface for a wallet loader. This
 //! function will be undefined in builds where ENABLE_WALLET is false.
-std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, ArgsManager& args);
+std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, const std::unique_ptr<CoinJoin::Loader>& coinjoin_loader, ArgsManager& args);
+
+std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet);
+std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman);
 
 } // namespace interfaces
 
diff --git a/src/node/context.cpp b/src/node/context.cpp
index 715272f9f18e..1bf8df550732 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -9,6 +9,7 @@
 #include <coinjoin/context.h>
 #include <evo/creditpool.h>
 #include <interfaces/chain.h>
+#include <interfaces/wallet.h>
 #include <llmq/context.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
diff --git a/src/node/context.h b/src/node/context.h
index 7a24527f035c..9fa01813114a 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -29,6 +29,9 @@ namespace interfaces {
 class Chain;
 class ChainClient;
 class WalletLoader;
+namespace CoinJoin {
+class Loader;
+} // namspace CoinJoin
 } // namespace interfaces
 
 //! NodeContext struct containing references to chain state and connection
@@ -56,6 +59,7 @@ struct NodeContext {
     //! Reference to chain client that should used to load or create wallets
     //! opened by the gui.
     interfaces::WalletLoader* wallet_loader{nullptr};
+    std::unique_ptr<interfaces::CoinJoin::Loader> coinjoin_loader{nullptr};
     std::unique_ptr<CScheduler> scheduler;
     std::function<void()> rpc_interruption_point = [] {};
     //! Dash
diff --git a/src/qt/test/addressbooktests.cpp b/src/qt/test/addressbooktests.cpp
index f646419a6c97..a4b3c30103d0 100644
--- a/src/qt/test/addressbooktests.cpp
+++ b/src/qt/test/addressbooktests.cpp
@@ -60,7 +60,7 @@ void TestAddAddressesToSendBook(interfaces::Node& node)
 {
     TestChain100Setup test;
     node.setContext(&test.m_node);
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), "", CreateMockWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), node.context()->coinjoin_loader, "", CreateMockWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     bool firstRun;
     wallet->LoadWallet(firstRun);
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index 85c799f88c5a..0b6ab7058690 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -108,7 +108,7 @@ void TestGUI(interfaces::Node& node)
         test.CreateAndProcessBlock({}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
     }
     node.setContext(&test.m_node);
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), "", CreateMockWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), node.context()->coinjoin_loader, "", CreateMockWalletDatabase());
     AddWallet(wallet);
     bool firstRun;
     wallet->LoadWallet(firstRun);
diff --git a/src/qt/walletcontroller.cpp b/src/qt/walletcontroller.cpp
index d34b75756ff4..d01f60ec841d 100644
--- a/src/qt/walletcontroller.cpp
+++ b/src/qt/walletcontroller.cpp
@@ -250,7 +250,7 @@ void CreateWalletActivity::createWallet()
     }
 
     QTimer::singleShot(500, worker(), [this, name, flags] {
-        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().createWallet(*::coinJoinWalletManager, name, m_passphrase, flags, m_error_message, m_warning_message);
+        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().createWallet(name, m_passphrase, flags, m_error_message, m_warning_message);
 
         if (wallet) m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(wallet));
 
@@ -321,7 +321,7 @@ void OpenWalletActivity::open(const std::string& path)
     showProgressDialog(tr("Opening Wallet <b>%1</b>...").arg(name.toHtmlEscaped()));
 
     QTimer::singleShot(0, worker(), [this, path] {
-        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().loadWallet(*::coinJoinWalletManager, path, m_error_message, m_warning_message);
+        std::unique_ptr<interfaces::Wallet> wallet = node().walletLoader().loadWallet(path, m_error_message, m_warning_message);
 
         if (wallet) m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(wallet));
 
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 821b52f574bf..5cd818cb3821 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -109,6 +109,9 @@ void DashTestSetup(NodeContext& node)
     CChainState& chainstate = Assert(node.chainman)->ActiveChainstate();
 
     node.cj_ctx = std::make_unique<CJContext>(chainstate, *node.connman, *node.mempool, *::masternodeSync, /* relay_txes */ true);
+#ifdef ENABLE_WALLET
+    node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*::coinJoinWalletManager);
+#endif // ENABLE_WALLET
     ::deterministicMNManager = std::make_unique<CDeterministicMNManager>(chainstate, *node.connman, *node.evodb);
     node.llmq_ctx = std::make_unique<LLMQContext>(chainstate, *node.connman, *node.evodb, *sporkManager, *node.mempool, node.peerman, true, false);
 }
diff --git a/src/wallet/context.cpp b/src/wallet/context.cpp
index 09b2f3046709..d0cd59c8e518 100644
--- a/src/wallet/context.cpp
+++ b/src/wallet/context.cpp
@@ -4,5 +4,7 @@
 
 #include <wallet/context.h>
 
-WalletContext::WalletContext() {}
+WalletContext::WalletContext(const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader) :
+    m_coinjoin_loader(coinjoin_loader)
+{}
 WalletContext::~WalletContext() {}
diff --git a/src/wallet/context.h b/src/wallet/context.h
index a83591154f0c..62cc1df98def 100644
--- a/src/wallet/context.h
+++ b/src/wallet/context.h
@@ -5,9 +5,14 @@
 #ifndef BITCOIN_WALLET_CONTEXT_H
 #define BITCOIN_WALLET_CONTEXT_H
 
+#include <memory>
+
 class ArgsManager;
 namespace interfaces {
 class Chain;
+namespace CoinJoin {
+class Loader;
+} // namspace CoinJoin
 } // namespace interfaces
 
 //! WalletContext struct containing references to state shared between CWallet
@@ -23,11 +28,12 @@ class Chain;
 struct WalletContext {
     interfaces::Chain* chain{nullptr};
     ArgsManager* args{nullptr};
+    const std::unique_ptr<interfaces::CoinJoin::Loader>& m_coinjoin_loader;
 
     //! Declare default constructor and destructor that are not inline, so code
     //! instantiating the WalletContext struct doesn't need to #include class
     //! definitions for smart pointer and container members.
-    WalletContext();
+    WalletContext(const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader);
     ~WalletContext();
 };
 
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index 91f57d85099d..177fa94c650c 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -185,7 +185,7 @@ void WalletInit::Construct(NodeContext& node) const
         LogPrintf("Wallet disabled!\n");
         return;
     }
-    auto wallet_loader = interfaces::MakeWalletLoader(*node.chain, args);
+    auto wallet_loader = interfaces::MakeWalletLoader(*node.chain, node.coinjoin_loader, args);
     node.wallet_loader = wallet_loader.get();
     node.chain_clients.emplace_back(std::move(wallet_loader));
 }
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 29f3676d5cc5..4c0ecd412dcb 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -121,13 +121,13 @@ WalletTxOut MakeWalletTxOut(const CWallet& wallet,
 }
 
 namespace CoinJoin = interfaces::CoinJoin;
-class CoinJoinImpl : public CoinJoin::Client
+class CoinJoinClientImpl : public CoinJoin::Client
 {
     CCoinJoinClientManager& m_clientman;
 
 public:
-    CoinJoinImpl(const CoinJoinWalletManager& walletman, const std::shared_ptr<CWallet>& wallet)
-        : m_clientman(*Assert(walletman.Get(*wallet))) {}
+    CoinJoinClientImpl(CCoinJoinClientManager& clientman)
+        : m_clientman(clientman) {}
 
     void resetCachedBlocks() override
     {
@@ -167,10 +167,32 @@ class CoinJoinImpl : public CoinJoin::Client
     }
 };
 
+class CoinJoinLoaderImpl : public CoinJoin::Loader
+{
+    CoinJoinWalletManager& m_walletman;
+
+public:
+    CoinJoinLoaderImpl(CoinJoinWalletManager& walletman)
+        : m_walletman(walletman) {}
+
+    void AddWallet(CWallet& wallet) override
+    {
+        m_walletman.Add(wallet);
+    }
+    void RemoveWallet(const std::string& name) override
+    {
+        m_walletman.Remove(name);
+    }
+    std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) override
+    {
+        return MakeCoinJoinClient(m_walletman, wallet);
+    }
+};
+
 class WalletImpl : public Wallet
 {
 public:
-    explicit WalletImpl(const std::shared_ptr<CWallet>& wallet, CoinJoinWalletManager& cjwalletman) : m_wallet(wallet), m_coinjoin(cjwalletman, wallet) {}
+    explicit WalletImpl(const std::shared_ptr<CWallet>& wallet, CoinJoinWalletManager& cjwalletman) : m_wallet(wallet), m_cjwalletman(cjwalletman) {}
 
     void markDirty() override
     {
@@ -550,7 +572,11 @@ class WalletImpl : public Wallet
     bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
     bool canGetAddresses() override { return m_wallet->CanGetAddresses(); }
     bool privateKeysDisabled() override { return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS); }
-    CoinJoin::Client& coinJoin() override { return m_coinjoin; }
+    CoinJoin::Client& coinJoin() override
+    {
+        if (m_coinjoin_client == nullptr) m_coinjoin_client = MakeCoinJoinClient(m_cjwalletman, *m_wallet);
+        return *m_coinjoin_client;
+    }
     CAmount getDefaultMaxTxFee() override { return m_wallet->m_default_max_tx_fee; }
     void remove() override
     {
@@ -600,13 +626,15 @@ class WalletImpl : public Wallet
     CWallet* wallet() override { return m_wallet.get(); }
 
     std::shared_ptr<CWallet> m_wallet;
-    CoinJoinImpl m_coinjoin;
+    CoinJoinWalletManager& m_cjwalletman;
+    std::unique_ptr<CoinJoin::Client> m_coinjoin_client;
 };
 
 class WalletLoaderImpl : public WalletLoader
 {
 public:
-    WalletLoaderImpl(Chain& chain, ArgsManager& args)
+    WalletLoaderImpl(Chain& chain, const std::unique_ptr<CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) :
+        m_context(coinjoin_loader)
     {
         m_context.chain = &chain;
         m_context.args = &args;
@@ -624,14 +652,14 @@ class WalletLoaderImpl : public WalletLoader
         }
     }
     bool verify() override { return VerifyWallets(*m_context.chain); }
-    bool load() override { return LoadWallets(*m_context.chain); }
+    bool load() override { assert(m_context.m_coinjoin_loader); return LoadWallets(*m_context.chain, m_context.m_coinjoin_loader); }
     void start(CScheduler& scheduler) override { return StartWallets(scheduler, *Assert(m_context.args)); }
     void flush() override { return FlushWallets(); }
     void stop() override { return StopWallets(); }
     void setMockTime(int64_t time) override { return SetMockTime(time); }
 
     //! WalletLoader methods
-    std::unique_ptr<Wallet> createWallet(const CoinJoinWalletManager& client_man, const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) override
+    std::unique_ptr<Wallet> createWallet(const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings) override
     {
         std::shared_ptr<CWallet> wallet;
         DatabaseOptions options;
@@ -639,14 +667,16 @@ class WalletLoaderImpl : public WalletLoader
         options.require_create = true;
         options.create_flags = wallet_creation_flags;
         options.create_passphrase = passphrase;
-        return MakeWallet(CreateWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings));
+        assert(m_context.m_coinjoin_loader);
+        return MakeWallet(CreateWallet(*m_context.chain, m_context.m_coinjoin_loader, name, true /* load_on_start */, options, status, error, warnings));
     }
-    std::unique_ptr<Wallet> loadWallet(const CoinJoinWalletManager& client_man, const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) override
+    std::unique_ptr<Wallet> loadWallet(const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) override
     {
         DatabaseOptions options;
         DatabaseStatus status;
         options.require_existing = true;
-        return MakeWallet(LoadWallet(*m_context.chain, name, true /* load_on_start */, options, status, error, warnings));
+        assert(m_context.m_coinjoin_loader);
+        return MakeWallet(LoadWallet(*m_context.chain, m_context.m_coinjoin_loader, name, true /* load_on_start */, options, status, error, warnings));
     }
     std::string getWalletDir() override
     {
@@ -683,7 +713,13 @@ class WalletLoaderImpl : public WalletLoader
 
 namespace interfaces {
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, *::coinJoinWalletManager) : nullptr; }
-std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, ArgsManager& args) {
-    return std::make_unique<wallet::WalletLoaderImpl>(chain, args);
+std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, const std::unique_ptr<CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) {
+    return std::make_unique<wallet::WalletLoaderImpl>(chain, coinjoin_loader, args);
+}
+std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet)
+{
+    auto clientman = walletman.Get(wallet);
+    return clientman ? std::make_unique<wallet::CoinJoinClientImpl>(*clientman) : nullptr;
 }
+std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman) { return std::make_unique<wallet::CoinJoinLoaderImpl>(walletman); }
 } // namespace interfaces
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 791a37f6b65e..946d67f7cd60 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -90,7 +90,7 @@ bool VerifyWallets(interfaces::Chain& chain)
     return true;
 }
 
-bool LoadWallets(interfaces::Chain& chain)
+bool LoadWallets(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader)
 {
     try {
         std::set<fs::path> wallet_paths;
@@ -108,7 +108,7 @@ bool LoadWallets(interfaces::Chain& chain)
             if (!database && status == DatabaseStatus::FAILED_NOT_FOUND) {
                 continue;
             }
-            std::shared_ptr<CWallet> pwallet = database ? CWallet::Create(chain, name, std::move(database), options.create_flags, error_string, warnings) : nullptr;
+            std::shared_ptr<CWallet> pwallet = database ? CWallet::Create(chain, coinjoin_loader, name, std::move(database), options.create_flags, error_string, warnings) : nullptr;
             if (!warnings.empty()) chain.initWarning(Join(warnings, Untranslated("\n")));
             if (!pwallet) {
                 chain.initError(error_string);
diff --git a/src/wallet/load.h b/src/wallet/load.h
index 7f7787c64b2f..23167bf5f2f9 100644
--- a/src/wallet/load.h
+++ b/src/wallet/load.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_WALLET_LOAD_H
 #define BITCOIN_WALLET_LOAD_H
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -15,13 +16,16 @@ class CScheduler;
 
 namespace interfaces {
 class Chain;
+namespace CoinJoin {
+class Loader;
+} // namespace CoinJoin
 } // namespace interfaces
 
 //! Responsible for reading and validating the -wallet arguments and verifying the wallet database.
 bool VerifyWallets(interfaces::Chain& chain);
 
 //! Load wallet databases.
-bool LoadWallets(interfaces::Chain& chain);
+bool LoadWallets(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader);
 
 //! Complete startup of wallets.
 void StartWallets(CScheduler& scheduler, const ArgsManager& args);
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 721c3af64e32..74492b593f2c 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -2805,7 +2805,7 @@ static UniValue loadwallet(const JSONRPCRequest& request)
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     std::optional<bool> load_on_start = request.params[1].isNull() ? std::nullopt : std::optional<bool>(request.params[1].get_bool());
-    std::shared_ptr<CWallet> const wallet = LoadWallet(*context.chain, name, load_on_start, options, status, error, warnings);
+    std::shared_ptr<CWallet> const wallet = LoadWallet(*context.chain, context.m_coinjoin_loader, name, load_on_start, options, status, error, warnings);
     if (!wallet) {
         // Map bad format to not found, since bad format is returned when the
         // wallet directory exists, but doesn't contain a data file.
@@ -2954,7 +2954,7 @@ static UniValue createwallet(const JSONRPCRequest& request)
     options.create_passphrase = passphrase;
     bilingual_str error;
     std::optional<bool> load_on_start = request.params[5].isNull() ? std::nullopt : std::optional<bool>(request.params[5].get_bool());
-    std::shared_ptr<CWallet> wallet = CreateWallet(*context.chain, request.params[0].get_str(), load_on_start, options, status, error, warnings);
+    std::shared_ptr<CWallet> wallet = CreateWallet(*context.chain, context.m_coinjoin_loader, request.params[0].get_str(), load_on_start, options, status, error, warnings);
     if (!wallet) {
         RPCErrorCode code = status == DatabaseStatus::FAILED_ENCRYPT ? RPC_WALLET_ENCRYPTION_FAILED : RPC_WALLET_ERROR;
         throw JSONRPCError(code, error.original);
diff --git a/src/wallet/salvage.cpp b/src/wallet/salvage.cpp
index 3f9b86e1588d..40576956edd1 100644
--- a/src/wallet/salvage.cpp
+++ b/src/wallet/salvage.cpp
@@ -133,7 +133,7 @@ bool RecoverDatabaseFile(const fs::path& file_path, bilingual_str& error, std::v
     }
 
     DbTxn* ptxn = env->TxnBegin();
-    CWallet dummyWallet(nullptr, "", CreateDummyWalletDatabase());
+    CWallet dummyWallet(nullptr, /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
     dummyWallet.SetupLegacyScriptPubKeyMan();
     for (KeyValPair& row : salvagedData)
     {
diff --git a/src/wallet/test/coinjoin_tests.cpp b/src/wallet/test/coinjoin_tests.cpp
index f20200dea3e7..14cb45c670c8 100644
--- a/src/wallet/test/coinjoin_tests.cpp
+++ b/src/wallet/test/coinjoin_tests.cpp
@@ -129,7 +129,7 @@ class CTransactionBuilderTestSetup : public TestChain100Setup
     CTransactionBuilderTestSetup()
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
-        wallet = std::make_unique<CWallet>(m_node.chain.get(), "", CreateMockWalletDatabase());
+        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
         wallet->SetupLegacyScriptPubKeyMan();
         bool firstRun;
         wallet->LoadWallet(firstRun);
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index 80db47319b36..2dad8ce8e521 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -30,7 +30,7 @@ typedef std::set<CInputCoin> CoinSet;
 static std::vector<COutput> vCoins;
 static NodeContext testNode;
 static auto testChain = interfaces::MakeChain(testNode);
-static CWallet testWallet(testChain.get(), "", CreateDummyWalletDatabase());
+static CWallet testWallet(testChain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
 static CAmount balance = 0;
 
 CoinEligibilityFilter filter_standard(1, 6, 0);
@@ -285,7 +285,7 @@ BOOST_AUTO_TEST_CASE(bnb_search_test)
     // Make sure that can use BnB when there are preset inputs
     empty_wallet();
     {
-        std::unique_ptr<CWallet> wallet = std::make_unique<CWallet>(m_node.chain.get(), "", CreateMockWalletDatabase());
+        std::unique_ptr<CWallet> wallet = std::make_unique<CWallet>(m_node.chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateMockWalletDatabase());
         wallet->SetupLegacyScriptPubKeyMan();
         bool firstRun;
         wallet->LoadWallet(firstRun);
diff --git a/src/wallet/test/init_test_fixture.cpp b/src/wallet/test/init_test_fixture.cpp
index afd9166236fb..a361ee077195 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -11,7 +11,7 @@
 
 InitWalletDirTestingSetup::InitWalletDirTestingSetup(const std::string& chainName) : BasicTestingSetup(chainName)
 {
-    m_wallet_loader = MakeWalletLoader(*m_node.chain, *Assert(m_node.args));
+    m_wallet_loader = MakeWalletLoader(*m_node.chain, m_node.coinjoin_loader, *Assert(m_node.args));
 
     std::string sep;
     sep += fs::path::preferred_separator;
diff --git a/src/wallet/test/init_test_fixture.h b/src/wallet/test/init_test_fixture.h
index 0dfc5767b444..449b99582142 100644
--- a/src/wallet/test/init_test_fixture.h
+++ b/src/wallet/test/init_test_fixture.h
@@ -19,6 +19,7 @@ struct InitWalletDirTestingSetup: public BasicTestingSetup {
     fs::path m_datadir;
     fs::path m_cwd;
     std::map<std::string, fs::path> m_walletdir_path_cases;
+    std::unique_ptr<interfaces::CoinJoin::Loader> m_coinjoin_loader;
     std::unique_ptr<interfaces::WalletLoader> m_wallet_loader;
 };
 
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
index 3fd0077ebaa3..56f6153233d6 100644
--- a/src/wallet/test/ismine_tests.cpp
+++ b/src/wallet/test/ismine_tests.cpp
@@ -35,7 +35,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // P2PK compressed
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForRawPubKey(pubkeys[0]);
@@ -52,7 +52,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // P2PK uncompressed
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForRawPubKey(uncompressedPubkey);
@@ -69,7 +69,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // P2PKH compressed
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForDestination(PKHash(pubkeys[0]));
@@ -86,7 +86,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // P2PKH uncompressed
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForDestination(PKHash(uncompressedPubkey));
@@ -103,7 +103,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // P2SH
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
 
@@ -127,7 +127,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     //  (P2PKH inside) P2SH inside P2SH (invalid)
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
 
@@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // scriptPubKey multisig
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
 
@@ -176,7 +176,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // P2SH multisig
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(uncompressedKey));
@@ -197,7 +197,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // OP_RETURN
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
@@ -211,7 +211,7 @@ BOOST_AUTO_TEST_CASE(ismine_standard)
 
     // Nonstandard
     {
-        CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
+        CWallet keystore(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
diff --git a/src/wallet/test/scriptpubkeyman_tests.cpp b/src/wallet/test/scriptpubkeyman_tests.cpp
index f7c1337b0dd0..25ffc15d77f2 100644
--- a/src/wallet/test/scriptpubkeyman_tests.cpp
+++ b/src/wallet/test/scriptpubkeyman_tests.cpp
@@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(CanProvide)
     // Set up wallet and keyman variables.
     NodeContext node;
     std::unique_ptr<interfaces::Chain> chain = interfaces::MakeChain(node);
-    CWallet wallet(chain.get(), "", CreateDummyWalletDatabase());
+    CWallet wallet(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
     LegacyScriptPubKeyMan& keyman = *wallet.GetOrCreateLegacyScriptPubKeyMan();
 
     // Make a 1 of 2 multisig script
diff --git a/src/wallet/test/wallet_test_fixture.cpp b/src/wallet/test/wallet_test_fixture.cpp
index 18fbfa1a113c..aefb8349bd30 100644
--- a/src/wallet/test/wallet_test_fixture.cpp
+++ b/src/wallet/test/wallet_test_fixture.cpp
@@ -7,8 +7,8 @@
 
 WalletTestingSetup::WalletTestingSetup(const std::string& chainName)
     : TestingSetup(chainName),
-      m_wallet_loader{interfaces::MakeWalletLoader(*m_node.chain, *Assert(m_node.args))},
-      m_wallet(m_node.chain.get(), "", CreateMockWalletDatabase())
+      m_wallet_loader{interfaces::MakeWalletLoader(*m_node.chain, m_node.coinjoin_loader, *Assert(m_node.args))},
+      m_wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase())
 {
     bool fFirstRun;
     m_wallet.LoadWallet(fFirstRun);
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 3fe6a8f633d1..dc182fb4d7fe 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -10,6 +10,7 @@
 #include <stdint.h>
 #include <vector>
 
+#include <coinjoin/client.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <node/context.h>
@@ -42,14 +43,14 @@ namespace {
 constexpr CAmount fallbackFee = 1000;
 } // anonymous namespace
 
-static std::shared_ptr<CWallet> TestLoadWallet(interfaces::Chain& chain)
+static std::shared_ptr<CWallet> TestLoadWallet(NodeContext& node)
 {
     DatabaseOptions options;
     DatabaseStatus status;
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     auto database = MakeWalletDatabase("", options, status, error);
-    auto wallet = CWallet::Create(chain, "", std::move(database), options.create_flags, error, warnings);
+    auto wallet = CWallet::Create(*node.chain, node.coinjoin_loader, "", std::move(database), options.create_flags, error, warnings);
     wallet->postInitProcess();
     return wallet;
 }
@@ -94,7 +95,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 
     // Verify ScanForWalletTransactions fails to read an unknown start block.
     {
-        CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         wallet.SetupLegacyScriptPubKeyMan();
         {
             LOCK(wallet.cs_wallet);
@@ -114,7 +115,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
     // Verify ScanForWalletTransactions picks up transactions in both the old
     // and new block files.
     {
-        CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -140,7 +141,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
     // Verify ScanForWalletTransactions only picks transactions in the new block
     // file.
     {
-        CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -165,7 +166,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 
     // Verify ScanForWalletTransactions scans no blocks.
     {
-        CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -201,7 +202,7 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
     // before the missing block, and success for a key whose creation time is
     // after.
     {
-        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         wallet->SetupLegacyScriptPubKeyMan();
         WITH_LOCK(wallet->cs_wallet, wallet->SetLastBlockProcessed(newTip->nHeight, newTip->GetBlockHash()));
         AddWallet(wallet);
@@ -263,7 +264,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
 
     // Import key into wallet and call dumpwallet to create backup file.
     {
-        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         {
             auto spk_man = wallet->GetOrCreateLegacyScriptPubKeyMan();
             LOCK2(wallet->cs_wallet, spk_man->cs_KeyStore);
@@ -286,7 +287,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
     // Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME
     // were scanned, and no prior blocks were scanned.
     {
-        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateDummyWalletDatabase());
+        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
         LOCK(wallet->cs_wallet);
         wallet->SetupLegacyScriptPubKeyMan();
 
@@ -314,7 +315,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
 // Verify getaddressinfo RPC produces more or less expected results
 BOOST_FIXTURE_TEST_CASE(rpc_getaddressinfo, TestChain100Setup)
 {
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateMockWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     AddWallet(wallet);
     CoreContext context{m_node};
@@ -395,7 +396,7 @@ BOOST_FIXTURE_TEST_CASE(rpc_getaddressinfo, TestChain100Setup)
 // debit functions.
 BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
 {
-    CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
+    CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
     auto spk_man = wallet.GetOrCreateLegacyScriptPubKeyMan();
     CWalletTx wtx(&wallet, m_coinbase_txns.back());
 
@@ -570,7 +571,7 @@ class ListCoinsTestingSetup : public TestChain100Setup
     ListCoinsTestingSetup()
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
-        wallet = std::make_unique<CWallet>(m_node.chain.get(), "", CreateMockWalletDatabase());
+        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
         {
             LOCK(wallet->cs_wallet);
             wallet->SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -618,6 +619,7 @@ class ListCoinsTestingSetup : public TestChain100Setup
     }
 
     std::unique_ptr<CWallet> wallet;
+    std::unique_ptr<interfaces::CoinJoin::Loader> coinjoin_loader;
 };
 
 BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
@@ -707,7 +709,7 @@ class CreateTransactionTestSetup : public TestChain100Setup
     CreateTransactionTestSetup()
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
-        wallet = std::make_unique<CWallet>(m_node.chain.get(), "", CreateMockWalletDatabase());
+        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
         bool firstRun;
         wallet->LoadWallet(firstRun);
         AddWallet(wallet);
@@ -727,6 +729,7 @@ class CreateTransactionTestSetup : public TestChain100Setup
         RemoveWallet(wallet, std::nullopt);
     }
 
+    std::unique_ptr<interfaces::CoinJoin::Loader> coinjoin_loader;
     std::shared_ptr<CWallet> wallet;
     CCoinControl coinControl;
 
@@ -1188,7 +1191,7 @@ BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)
     node.fee_estimator = std::make_unique<CBlockPolicyEstimator>();
     node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get());
     auto chain = interfaces::MakeChain(node);
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(chain.get(), "", CreateDummyWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     wallet->SetMinVersion(FEATURE_LATEST);
     wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
@@ -1220,7 +1223,7 @@ BOOST_FIXTURE_TEST_CASE(CreateWalletFromFile, TestChain100Setup)
 {
     gArgs.ForceSetArg("-unsafesqlitesync", "1");
     // Create new wallet with known key and unload it.
-    auto wallet = TestLoadWallet(*m_node.chain);
+    auto wallet = TestLoadWallet(m_node);
     CKey key;
     key.MakeNewKey(true);
     AddKey(*wallet, key);
@@ -1260,7 +1263,7 @@ BOOST_FIXTURE_TEST_CASE(CreateWalletFromFile, TestChain100Setup)
 
     // Reload wallet and make sure new transactions are detected despite events
     // being blocked
-    wallet = TestLoadWallet(*m_node.chain);
+    wallet = TestLoadWallet(m_node);
     BOOST_CHECK(rescan_completed);
     BOOST_CHECK_EQUAL(addtx_count, 2);
     {
@@ -1299,7 +1302,7 @@ BOOST_FIXTURE_TEST_CASE(CreateWalletFromFile, TestChain100Setup)
             ENTER_CRITICAL_SECTION(wallet->wallet()->cs_wallet);
             ENTER_CRITICAL_SECTION(cs_wallets);
         });
-    wallet = TestLoadWallet(*m_node.chain);
+    wallet = TestLoadWallet(m_node);
     BOOST_CHECK_EQUAL(addtx_count, 4);
     {
         LOCK(wallet->cs_wallet);
@@ -1332,7 +1335,8 @@ static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
     node.fee_estimator = std::make_unique<CBlockPolicyEstimator>();
     node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get());
     auto chain = interfaces::MakeChain(node);
-    CWallet wallet(chain.get(), "", CreateDummyWalletDatabase());
+    auto coinjoin_loader = interfaces::MakeCoinJoinLoader(*::coinJoinWalletManager);
+    CWallet wallet(chain.get(), coinjoin_loader, "", CreateDummyWalletDatabase());
     AddKey(wallet, key);
     auto spk_man = wallet.GetLegacyScriptPubKeyMan();
     spk_man->AddCScript(inner_script);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 001846742bbb..f165af8c5f65 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -41,7 +41,7 @@
 #include <wallet/fees.h>
 #include <warnings.h>
 
-#include <coinjoin/client.h>
+#include <coinjoin/common.h>
 #include <coinjoin/options.h>
 #include <evo/providertx.h>
 
@@ -113,8 +113,7 @@ bool AddWallet(const std::shared_ptr<CWallet>& wallet)
     }
     wallet->ConnectScriptPubKeyManNotifiers();
     wallet->AutoLockMasternodeCollaterals();
-    assert(::coinJoinWalletManager != nullptr);
-    ::coinJoinWalletManager->Add(*wallet);
+    wallet->coinjoin_loader().AddWallet(*wallet);
     wallet->NotifyCanGetAddressesChanged();
     return true;
 }
@@ -135,8 +134,7 @@ bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> lo
         vpwallets.erase(i);
     }
 
-    assert(::coinJoinWalletManager != nullptr);
-    ::coinJoinWalletManager->Remove(name);
+    wallet->coinjoin_loader().RemoveWallet(name);
 
     // Write the wallet setting
     UpdateWalletSetting(chain, name, load_on_start, warnings);
@@ -221,7 +219,7 @@ void UnloadWallet(std::shared_ptr<CWallet>&& wallet)
 }
 
 namespace {
-std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
     try {
         std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
@@ -230,7 +228,7 @@ std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, const std:
             return nullptr;
         }
 
-        std::shared_ptr<CWallet> wallet = CWallet::Create(chain, name, std::move(database), options.create_flags, error, warnings);
+        std::shared_ptr<CWallet> wallet = CWallet::Create(chain, coinjoin_loader, name, std::move(database), options.create_flags, error, warnings);
         if (!wallet) {
             error = Untranslated("Wallet loading failed.") + Untranslated(" ") + error;
             status = DatabaseStatus::FAILED_LOAD;
@@ -251,7 +249,7 @@ std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, const std:
 }
 } // namespace
 
-std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
     auto result = WITH_LOCK(g_loading_wallet_mutex, return g_loading_wallet_set.insert(name));
     if (!result.second) {
@@ -259,12 +257,12 @@ std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::string&
         status = DatabaseStatus::FAILED_LOAD;
         return nullptr;
     }
-    auto wallet = LoadWalletInternal(chain, name, load_on_start, options, status, error, warnings);
+    auto wallet = LoadWalletInternal(chain, coinjoin_loader, name, load_on_start, options, status, error, warnings);
     WITH_LOCK(g_loading_wallet_mutex, g_loading_wallet_set.erase(result.first));
     return wallet;
 }
 
-std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
     uint64_t wallet_creation_flags = options.create_flags;
     const SecureString& passphrase = options.create_passphrase;
@@ -293,7 +291,7 @@ std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::strin
     }
 
     // Make the wallet
-    std::shared_ptr<CWallet> wallet = CWallet::Create(chain, name, std::move(database), wallet_creation_flags, error, warnings);
+    std::shared_ptr<CWallet> wallet = CWallet::Create(chain, coinjoin_loader, name, std::move(database), wallet_creation_flags, error, warnings);
     if (!wallet) {
         error = Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
         status = DatabaseStatus::FAILED_CREATE;
@@ -1632,9 +1630,11 @@ void CWallet::UnsetBlankWalletFlag(WalletBatch& batch)
 
 void CWallet::NewKeyPoolCallback()
 {
-    assert(::coinJoinWalletManager != nullptr);
-    auto cj_clientman = ::coinJoinWalletManager->Get(*this);
-    if (cj_clientman != nullptr) cj_clientman->StopMixing();
+    // Note: GetClient(*this) can return nullptr when this wallet is in the middle of its creation.
+    // Skipping stopMixing() is fine in this case.
+    if (std::unique_ptr<interfaces::CoinJoin::Client> coinjoin_client = coinjoin_loader().GetClient(*this)) {
+        coinjoin_client->stopMixing();
+    }
     nKeysLeftSinceAutoBackup = 0;
 }
 
@@ -4508,8 +4508,9 @@ std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, cons
     return MakeDatabase(wallet_path, options, status, error_string);
 }
 
-std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
+    assert(coinjoin_loader);
     const std::string& walletFile = database->Filename();
 
     chain.initMessage(_("Loading wallet...").translated);
@@ -4518,7 +4519,7 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::st
     bool fFirstRun = true;
     // TODO: Can't use std::make_shared because we need a custom deleter but
     // should be possible to use std::allocate_shared.
-    std::shared_ptr<CWallet> walletInstance(new CWallet(&chain, name, std::move(database)), ReleaseWallet);
+    std::shared_ptr<CWallet> walletInstance(new CWallet(&chain, coinjoin_loader, name, std::move(database)), ReleaseWallet);
     if (!walletInstance->AutoBackupWallet(walletFile, error, warnings) && !error.original.empty()) {
         return nullptr;
     }
@@ -4818,8 +4819,7 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::st
         walletInstance->GetDatabase().IncrementUpdateCounter();
     }
 
-    assert(::coinJoinWalletManager != nullptr);
-    ::coinJoinWalletManager->Add(*walletInstance);
+    coinjoin_loader->AddWallet(*walletInstance);
 
     {
         LOCK(cs_wallets);
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index ad3e9335ffaa..ce77f23376de 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -11,6 +11,7 @@
 #include <governance/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
+#include <interfaces/wallet.h>
 #include <policy/feerate.h>
 #include <psbt.h>
 #include <saltedhasher.h>
@@ -59,8 +60,8 @@ bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> lo
 bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start);
 std::vector<std::shared_ptr<CWallet>> GetWallets();
 std::shared_ptr<CWallet> GetWallet(const std::string& name);
-std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
-std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
+std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
+std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
 std::unique_ptr<interfaces::Handler> HandleLoadWallet(LoadWalletFn load_wallet);
 std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error);
 
@@ -758,6 +759,9 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     /** Interface for accessing chain state. */
     interfaces::Chain* m_chain;
 
+    /** Interface for accessing CoinJoin state. */
+    const std::unique_ptr<interfaces::CoinJoin::Loader>& m_coinjoin_loader;
+
     /** Wallet name: relative directory name or "" for default wallet. */
     std::string m_name;
 
@@ -834,9 +838,10 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     unsigned int nMasterKeyMaxID = 0;
 
     /** Construct wallet with specified name and database implementation. */
-    CWallet(interfaces::Chain* chain, const std::string& name, std::unique_ptr<WalletDatabase> database)
+    CWallet(interfaces::Chain* chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database)
         : fOnlyMixingAllowed(false),
           m_chain(chain),
+          m_coinjoin_loader(coinjoin_loader),
           m_name(name),
           m_database(std::move(database))
     {
@@ -877,6 +882,9 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     /** Interface for accessing chain state. */
     interfaces::Chain& chain() const { assert(m_chain); return *m_chain; }
 
+    /** Interface for accessing CoinJoin state. */
+    interfaces::CoinJoin::Loader& coinjoin_loader() { assert(m_coinjoin_loader); return *m_coinjoin_loader.get(); }
+
     const CWalletTx* GetWalletTx(const uint256& hash) const;
 
     //! check whether we are allowed to upgrade (or already support) to the named feature
@@ -1246,7 +1254,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     bool ResendTransaction(const uint256& hashTx);
 
     /* Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error */
-    static std::shared_ptr<CWallet> Create(interfaces::Chain& chain, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings);
+    static std::shared_ptr<CWallet> Create(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings);
 
     /**
      * Wallet post-init setup
diff --git a/src/wallet/wallettool.cpp b/src/wallet/wallettool.cpp
index bf6ea0ed586c..e69a94b97341 100644
--- a/src/wallet/wallettool.cpp
+++ b/src/wallet/wallettool.cpp
@@ -53,7 +53,7 @@ static std::shared_ptr<CWallet> MakeWallet(const std::string& name, const fs::pa
     }
 
     // dummy chain interface
-    std::shared_ptr<CWallet> wallet_instance{new CWallet(nullptr /* chain */, name, std::move(database)), WalletToolReleaseWallet};
+    std::shared_ptr<CWallet> wallet_instance{new CWallet(/*chain=*/ nullptr, /*coinjoin_loader=*/ nullptr, name, std::move(database)), WalletToolReleaseWallet};
     DBErrors load_wallet_ret;
     try {
         bool first_run;

From 66884d9100542b3443fbdf5c79159735c9d3c881 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Mon, 1 Jan 2024 13:13:25 +0300
Subject: [PATCH 12/22] refactor: split CoinJoin interfaces out of wallet into
 their own files

---
 src/Makefile.am             |  2 +
 src/coinjoin/interfaces.cpp | 94 +++++++++++++++++++++++++++++++++++++
 src/interfaces/coinjoin.h   | 48 +++++++++++++++++++
 src/interfaces/wallet.h     | 33 +------------
 src/node/context.cpp        |  2 +-
 src/wallet/interfaces.cpp   | 86 +++------------------------------
 src/wallet/wallet.h         |  2 +-
 7 files changed, 153 insertions(+), 114 deletions(-)
 create mode 100644 src/coinjoin/interfaces.cpp
 create mode 100644 src/interfaces/coinjoin.h

diff --git a/src/Makefile.am b/src/Makefile.am
index e6179b9d1200..69941e6a3a9a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -211,6 +211,7 @@ BITCOIN_CORE_H = \
   indirectmap.h \
   init.h \
   interfaces/chain.h \
+  interfaces/coinjoin.h \
   interfaces/handler.h \
   interfaces/node.h \
   interfaces/wallet.h \
@@ -528,6 +529,7 @@ endif
 libbitcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(SQLITE_CFLAGS)
 libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
+  coinjoin/interfaces.cpp \
   hdchain.cpp \
   wallet/coincontrol.cpp \
   wallet/context.cpp \
diff --git a/src/coinjoin/interfaces.cpp b/src/coinjoin/interfaces.cpp
new file mode 100644
index 000000000000..9ef6b725223c
--- /dev/null
+++ b/src/coinjoin/interfaces.cpp
@@ -0,0 +1,94 @@
+// Copyright (c) 2024 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interfaces/coinjoin.h>
+
+#include <coinjoin/client.h>
+#include <wallet/wallet.h>
+
+#include <memory>
+#include <string>
+
+namespace coinjoin {
+namespace {
+
+class CoinJoinClientImpl : public interfaces::CoinJoin::Client
+{
+    CCoinJoinClientManager& m_clientman;
+
+public:
+    explicit CoinJoinClientImpl(CCoinJoinClientManager& clientman)
+        : m_clientman(clientman) {}
+
+    void resetCachedBlocks() override
+    {
+        m_clientman.nCachedNumBlocks = std::numeric_limits<int>::max();
+    }
+    void resetPool() override
+    {
+        m_clientman.ResetPool();
+    }
+    void disableAutobackups() override
+    {
+        m_clientman.fCreateAutoBackups = false;
+    }
+    int getCachedBlocks() override
+    {
+        return m_clientman.nCachedNumBlocks;
+    }
+    std::string getSessionDenoms() override
+    {
+        return m_clientman.GetSessionDenoms();
+    }
+    void setCachedBlocks(int nCachedBlocks) override
+    {
+       m_clientman.nCachedNumBlocks = nCachedBlocks;
+    }
+    bool isMixing() override
+    {
+        return m_clientman.IsMixing();
+    }
+    bool startMixing() override
+    {
+        return m_clientman.StartMixing();
+    }
+    void stopMixing() override
+    {
+        m_clientman.StopMixing();
+    }
+};
+
+class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
+{
+    CoinJoinWalletManager& m_walletman;
+
+public:
+    explicit CoinJoinLoaderImpl(CoinJoinWalletManager& walletman)
+        : m_walletman(walletman) {}
+
+    void AddWallet(CWallet& wallet) override
+    {
+        m_walletman.Add(wallet);
+    }
+    void RemoveWallet(const std::string& name) override
+    {
+        m_walletman.Remove(name);
+    }
+    std::unique_ptr<interfaces::CoinJoin::Client> GetClient(const CWallet& wallet) override
+    {
+        return interfaces::MakeCoinJoinClient(m_walletman, wallet);
+    }
+};
+
+} // namespace
+} // namespace coinjoin
+
+namespace interfaces {
+std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet)
+{
+    auto clientman = walletman.Get(wallet);
+    return clientman ? std::make_unique<coinjoin::CoinJoinClientImpl>(*clientman) : nullptr;
+}
+std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman) { return std::make_unique<coinjoin::CoinJoinLoaderImpl>(walletman); }
+} // namespace interfaces
diff --git a/src/interfaces/coinjoin.h b/src/interfaces/coinjoin.h
new file mode 100644
index 000000000000..a2f394f39469
--- /dev/null
+++ b/src/interfaces/coinjoin.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2024 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_COINJOIN_H
+#define BITCOIN_INTERFACES_COINJOIN_H
+
+#include <memory>
+#include <string>
+
+class CoinJoinWalletManager;
+class CWallet;
+
+namespace interfaces {
+namespace CoinJoin {
+//! Interface for the wallet constrained src/coinjoin part of a dash node (dashd process).
+class Client
+{
+public:
+    virtual ~Client() {}
+    virtual void resetCachedBlocks() = 0;
+    virtual void resetPool() = 0;
+    virtual int getCachedBlocks() = 0;
+    virtual std::string getSessionDenoms() = 0;
+    virtual void setCachedBlocks(int nCachedBlocks) = 0;
+    virtual void disableAutobackups() = 0;
+    virtual bool isMixing() = 0;
+    virtual bool startMixing() = 0;
+    virtual void stopMixing() = 0;
+};
+class Loader
+{
+public:
+    virtual ~Loader() {}
+    //! Add new wallet to CoinJoin client manager
+    virtual void AddWallet(CWallet&) = 0;
+    //! Remove wallet from CoinJoin client manager
+    virtual void RemoveWallet(const std::string&) = 0;
+    virtual std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) = 0;
+};
+} // namespace CoinJoin
+
+std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet);
+std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman);
+
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_COINJOIN_H
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index dfe456a24adb..807cedae9096 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -8,6 +8,7 @@
 #include <amount.h>                    // For CAmount
 #include <fs.h>                        // For fs::path
 #include <interfaces/chain.h>          // For ChainClient
+#include <interfaces/coinjoin.h>       // For CoinJoin::*
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
@@ -26,7 +27,6 @@
 
 class CCoinControl;
 class CFeeRate;
-class CoinJoinWalletManager;
 class CKey;
 class CWallet;
 class UniValue;
@@ -52,34 +52,6 @@ struct WalletTxStatus;
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
 
-namespace CoinJoin {
-//! Interface for the wallet constrained src/coinjoin part of a dash node (dashd process).
-class Client
-{
-public:
-    virtual ~Client() {}
-    virtual void resetCachedBlocks() = 0;
-    virtual void resetPool() = 0;
-    virtual int getCachedBlocks() = 0;
-    virtual std::string getSessionDenoms() = 0;
-    virtual void setCachedBlocks(int nCachedBlocks) = 0;
-    virtual void disableAutobackups() = 0;
-    virtual bool isMixing() = 0;
-    virtual bool startMixing() = 0;
-    virtual void stopMixing() = 0;
-};
-class Loader
-{
-public:
-    virtual ~Loader() {}
-    //! Add new wallet to CoinJoin client manager
-    virtual void AddWallet(CWallet&) = 0;
-    //! Remove wallet from CoinJoin client manager
-    virtual void RemoveWallet(const std::string&) = 0;
-    virtual std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) = 0;
-};
-}
-
 //! Interface for accessing a wallet.
 class Wallet
 {
@@ -472,9 +444,6 @@ std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet);
 //! function will be undefined in builds where ENABLE_WALLET is false.
 std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, const std::unique_ptr<CoinJoin::Loader>& coinjoin_loader, ArgsManager& args);
 
-std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet);
-std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman);
-
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_WALLET_H
diff --git a/src/node/context.cpp b/src/node/context.cpp
index 1bf8df550732..5602cb335fcc 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -9,7 +9,7 @@
 #include <coinjoin/context.h>
 #include <evo/creditpool.h>
 #include <interfaces/chain.h>
-#include <interfaces/wallet.h>
+#include <interfaces/coinjoin.h>
 #include <llmq/context.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 4c0ecd412dcb..abc3d75114e7 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -7,6 +7,7 @@
 #include <amount.h>
 #include <coinjoin/client.h>
 #include <interfaces/chain.h>
+#include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
@@ -120,75 +121,6 @@ WalletTxOut MakeWalletTxOut(const CWallet& wallet,
     return result;
 }
 
-namespace CoinJoin = interfaces::CoinJoin;
-class CoinJoinClientImpl : public CoinJoin::Client
-{
-    CCoinJoinClientManager& m_clientman;
-
-public:
-    CoinJoinClientImpl(CCoinJoinClientManager& clientman)
-        : m_clientman(clientman) {}
-
-    void resetCachedBlocks() override
-    {
-        m_clientman.nCachedNumBlocks = std::numeric_limits<int>::max();
-    }
-    void resetPool() override
-    {
-        m_clientman.ResetPool();
-    }
-    void disableAutobackups() override
-    {
-        m_clientman.fCreateAutoBackups = false;
-    }
-    int getCachedBlocks() override
-    {
-        return m_clientman.nCachedNumBlocks;
-    }
-    std::string getSessionDenoms() override
-    {
-        return m_clientman.GetSessionDenoms();
-    }
-    void setCachedBlocks(int nCachedBlocks) override
-    {
-       m_clientman.nCachedNumBlocks = nCachedBlocks;
-    }
-    bool isMixing() override
-    {
-        return m_clientman.IsMixing();
-    }
-    bool startMixing() override
-    {
-        return m_clientman.StartMixing();
-    }
-    void stopMixing() override
-    {
-        m_clientman.StopMixing();
-    }
-};
-
-class CoinJoinLoaderImpl : public CoinJoin::Loader
-{
-    CoinJoinWalletManager& m_walletman;
-
-public:
-    CoinJoinLoaderImpl(CoinJoinWalletManager& walletman)
-        : m_walletman(walletman) {}
-
-    void AddWallet(CWallet& wallet) override
-    {
-        m_walletman.Add(wallet);
-    }
-    void RemoveWallet(const std::string& name) override
-    {
-        m_walletman.Remove(name);
-    }
-    std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) override
-    {
-        return MakeCoinJoinClient(m_walletman, wallet);
-    }
-};
-
 class WalletImpl : public Wallet
 {
 public:
@@ -572,9 +504,9 @@ class WalletImpl : public Wallet
     bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
     bool canGetAddresses() override { return m_wallet->CanGetAddresses(); }
     bool privateKeysDisabled() override { return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS); }
-    CoinJoin::Client& coinJoin() override
+    interfaces::CoinJoin::Client& coinJoin() override
     {
-        if (m_coinjoin_client == nullptr) m_coinjoin_client = MakeCoinJoinClient(m_cjwalletman, *m_wallet);
+        if (m_coinjoin_client == nullptr) m_coinjoin_client = interfaces::MakeCoinJoinClient(m_cjwalletman, *m_wallet);
         return *m_coinjoin_client;
     }
     CAmount getDefaultMaxTxFee() override { return m_wallet->m_default_max_tx_fee; }
@@ -627,13 +559,13 @@ class WalletImpl : public Wallet
 
     std::shared_ptr<CWallet> m_wallet;
     CoinJoinWalletManager& m_cjwalletman;
-    std::unique_ptr<CoinJoin::Client> m_coinjoin_client;
+    std::unique_ptr<interfaces::CoinJoin::Client> m_coinjoin_client;
 };
 
 class WalletLoaderImpl : public WalletLoader
 {
 public:
-    WalletLoaderImpl(Chain& chain, const std::unique_ptr<CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) :
+    WalletLoaderImpl(Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) :
         m_context(coinjoin_loader)
     {
         m_context.chain = &chain;
@@ -713,13 +645,7 @@ class WalletLoaderImpl : public WalletLoader
 
 namespace interfaces {
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, *::coinJoinWalletManager) : nullptr; }
-std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, const std::unique_ptr<CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) {
+std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) {
     return std::make_unique<wallet::WalletLoaderImpl>(chain, coinjoin_loader, args);
 }
-std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet)
-{
-    auto clientman = walletman.Get(wallet);
-    return clientman ? std::make_unique<wallet::CoinJoinClientImpl>(*clientman) : nullptr;
-}
-std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman) { return std::make_unique<wallet::CoinJoinLoaderImpl>(walletman); }
 } // namespace interfaces
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index ce77f23376de..e57b926fd749 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -10,8 +10,8 @@
 #include <amount.h>
 #include <governance/common.h>
 #include <interfaces/chain.h>
+#include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
-#include <interfaces/wallet.h>
 #include <policy/feerate.h>
 #include <psbt.h>
 #include <saltedhasher.h>

From a477cdbfce7acefe1c215fccdd47dd00626de76c Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Mon, 1 Jan 2024 13:15:01 +0300
Subject: [PATCH 13/22] refactor: move client-side CoinJoin out of server

---
 src/Makefile.am | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Makefile.am b/src/Makefile.am
index 69941e6a3a9a..6e416fa1cf6f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -403,11 +403,9 @@ libbitcoin_server_a_SOURCES = \
   blockencodings.cpp \
   blockfilter.cpp \
   chain.cpp \
-  coinjoin/client.cpp \
   coinjoin/coinjoin.cpp \
   coinjoin/context.cpp \
   coinjoin/server.cpp \
-  coinjoin/util.cpp \
   consensus/tx_verify.cpp \
   dbwrapper.cpp \
   deploymentstatus.cpp \
@@ -529,7 +527,9 @@ endif
 libbitcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(SQLITE_CFLAGS)
 libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
+  coinjoin/client.cpp \
   coinjoin/interfaces.cpp \
+  coinjoin/util.cpp \
   hdchain.cpp \
   wallet/coincontrol.cpp \
   wallet/context.cpp \

From fc582937f162ff525553c461b5837d3b0594bcad Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 11:58:02 +0700
Subject: [PATCH 14/22] chore: drop circular dependency coinjoin/client <->
 wallet

---
 test/lint/lint-circular-dependencies.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index bd899e9ae9ee..bf9067012574 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -62,7 +62,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "logging -> util/system -> sync -> logging"
     "logging -> util/system -> stacktraces -> logging"
     "logging -> util/system -> util/getuniquepath -> random -> logging"
-    "coinjoin/client -> coinjoin/util -> wallet/wallet -> coinjoin/client"
     "coinjoin/client -> net_processing -> coinjoin/context -> coinjoin/client"
     "coinjoin/context -> coinjoin/server -> net_processing -> coinjoin/context"
     "qt/appearancewidget -> qt/guiutil -> qt/optionsdialog -> qt/appearancewidget"

From 4846c31321db7538a3b04ac1348ef4beda861de7 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 13 Dec 2023 12:51:18 +0700
Subject: [PATCH 15/22] refactor: remove dependency wallet/load on CoinJoin by
 creating new interface method for flush

---
 src/coinjoin/client.cpp     | 8 ++++++++
 src/coinjoin/client.h       | 1 +
 src/coinjoin/interfaces.cpp | 4 ++++
 src/interfaces/coinjoin.h   | 1 +
 src/wallet/load.cpp         | 5 +----
 5 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 083b8410775f..00e2642fcfdc 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -1908,3 +1908,11 @@ void CoinJoinWalletManager::Remove(const std::string& name) {
     m_wallet_manager_map.erase(name);
     g_wallet_init_interface.InitCoinJoinSettings(*this);
 }
+
+void CoinJoinWalletManager::Flush(const CWallet& wallet)
+{
+    auto clientman = Get(wallet);
+    assert(clientman != nullptr);
+    clientman->ResetPool();
+    clientman->StopMixing();
+}
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 7600a1dced29..7aa74254847a 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -87,6 +87,7 @@ class CoinJoinWalletManager {
     void DoMaintenance(CBlockPolicyEstimator& fee_estimator);
 
     void Remove(const std::string& name);
+    void Flush(const CWallet& wallet);
 
     CCoinJoinClientManager* Get(const CWallet& wallet) const {
         auto it = m_wallet_manager_map.find(wallet.GetName());
diff --git a/src/coinjoin/interfaces.cpp b/src/coinjoin/interfaces.cpp
index 9ef6b725223c..f573ece89ffd 100644
--- a/src/coinjoin/interfaces.cpp
+++ b/src/coinjoin/interfaces.cpp
@@ -75,6 +75,10 @@ class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
     {
         m_walletman.Remove(name);
     }
+    void FlushWallet(const CWallet& wallet) override
+    {
+        m_walletman.Flush(wallet);
+    }
     std::unique_ptr<interfaces::CoinJoin::Client> GetClient(const CWallet& wallet) override
     {
         return interfaces::MakeCoinJoinClient(m_walletman, wallet);
diff --git a/src/interfaces/coinjoin.h b/src/interfaces/coinjoin.h
index a2f394f39469..be8d36849db9 100644
--- a/src/interfaces/coinjoin.h
+++ b/src/interfaces/coinjoin.h
@@ -36,6 +36,7 @@ class Loader
     virtual void AddWallet(CWallet&) = 0;
     //! Remove wallet from CoinJoin client manager
     virtual void RemoveWallet(const std::string&) = 0;
+    virtual void FlushWallet(const CWallet&) = 0;
     virtual std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) = 0;
 };
 } // namespace CoinJoin
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 946d67f7cd60..7f8cdb37ebb8 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -141,10 +141,7 @@ void FlushWallets()
     for (const std::shared_ptr<CWallet>& pwallet : GetWallets()) {
         if (CCoinJoinClientOptions::IsEnabled()) {
             // Stop CoinJoin, release keys
-            auto cj_clientman = ::coinJoinWalletManager->Get(*pwallet);
-            assert(cj_clientman != nullptr);
-            cj_clientman->ResetPool();
-            cj_clientman->StopMixing();
+            pwallet->coinjoin_loader().FlushWallet(*pwallet);
         }
         pwallet->Flush();
     }

From 60240b1fde8ef74a6d32f3a544bde8c6d44d8227 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Mon, 1 Jan 2024 19:33:07 +0300
Subject: [PATCH 16/22] refactor: pass wallet name instead of wallet itself
 when possible

---
 src/coinjoin/client.cpp     | 16 +++++++++++-----
 src/coinjoin/client.h       |  9 +++------
 src/coinjoin/interfaces.cpp | 12 ++++++------
 src/interfaces/coinjoin.h   |  6 +++---
 src/rpc/coinjoin.cpp        |  4 ++--
 src/wallet/init.cpp         |  2 +-
 src/wallet/interfaces.cpp   |  2 +-
 src/wallet/load.cpp         |  2 +-
 src/wallet/wallet.cpp       |  2 +-
 9 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 00e2642fcfdc..4be282e2accc 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -157,11 +157,11 @@ void CCoinJoinClientManager::ProcessMessage(CNode& peer, PeerManager& peerman, C
     }
 }
 
-CCoinJoinClientSession::CCoinJoinClientSession(CWallet& pwallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
+CCoinJoinClientSession::CCoinJoinClientSession(CWallet& wallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
                                                const std::unique_ptr<CCoinJoinClientQueueManager>& queueman) :
-    m_wallet(pwallet),
+    m_wallet(wallet),
     m_walletman(walletman),
-    m_manager(*Assert(walletman.Get(pwallet))),
+    m_manager(*Assert(walletman.Get(wallet.GetName()))),
     m_mn_sync(mn_sync),
     m_queueman(queueman)
 {}
@@ -1909,10 +1909,16 @@ void CoinJoinWalletManager::Remove(const std::string& name) {
     g_wallet_init_interface.InitCoinJoinSettings(*this);
 }
 
-void CoinJoinWalletManager::Flush(const CWallet& wallet)
+void CoinJoinWalletManager::Flush(const std::string& name)
 {
-    auto clientman = Get(wallet);
+    auto clientman = Get(name);
     assert(clientman != nullptr);
     clientman->ResetPool();
     clientman->StopMixing();
 }
+
+CCoinJoinClientManager* CoinJoinWalletManager::Get(const std::string& name) const
+{
+    auto it = m_wallet_manager_map.find(name);
+    return (it != m_wallet_manager_map.end()) ? it->second.get() : nullptr;
+}
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 7aa74254847a..82e1e04fd4dc 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -87,12 +87,9 @@ class CoinJoinWalletManager {
     void DoMaintenance(CBlockPolicyEstimator& fee_estimator);
 
     void Remove(const std::string& name);
-    void Flush(const CWallet& wallet);
+    void Flush(const std::string& name);
 
-    CCoinJoinClientManager* Get(const CWallet& wallet) const {
-        auto it = m_wallet_manager_map.find(wallet.GetName());
-        return (it != m_wallet_manager_map.end()) ? it->second.get() : nullptr;
-    }
+    CCoinJoinClientManager* Get(const std::string& name) const;
 
     const wallet_name_cjman_map& raw() const { return m_wallet_manager_map; }
 
@@ -162,7 +159,7 @@ class CCoinJoinClientSession : public CCoinJoinBaseSession
     void SetNull() EXCLUSIVE_LOCKS_REQUIRED(cs_coinjoin);
 
 public:
-    explicit CCoinJoinClientSession(CWallet& pwallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
+    explicit CCoinJoinClientSession(CWallet& wallet, CoinJoinWalletManager& walletman, const CMasternodeSync& mn_sync,
                                     const std::unique_ptr<CCoinJoinClientQueueManager>& queueman);
 
     void ProcessMessage(CNode& peer, PeerManager& peerman, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv);
diff --git a/src/coinjoin/interfaces.cpp b/src/coinjoin/interfaces.cpp
index f573ece89ffd..d5058b75bf2a 100644
--- a/src/coinjoin/interfaces.cpp
+++ b/src/coinjoin/interfaces.cpp
@@ -75,13 +75,13 @@ class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
     {
         m_walletman.Remove(name);
     }
-    void FlushWallet(const CWallet& wallet) override
+    void FlushWallet(const std::string& name) override
     {
-        m_walletman.Flush(wallet);
+        m_walletman.Flush(name);
     }
-    std::unique_ptr<interfaces::CoinJoin::Client> GetClient(const CWallet& wallet) override
+    std::unique_ptr<interfaces::CoinJoin::Client> GetClient(const std::string& name) override
     {
-        return interfaces::MakeCoinJoinClient(m_walletman, wallet);
+        return interfaces::MakeCoinJoinClient(m_walletman, name);
     }
 };
 
@@ -89,9 +89,9 @@ class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
 } // namespace coinjoin
 
 namespace interfaces {
-std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet)
+std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const std::string& name)
 {
-    auto clientman = walletman.Get(wallet);
+    auto clientman = walletman.Get(name);
     return clientman ? std::make_unique<coinjoin::CoinJoinClientImpl>(*clientman) : nullptr;
 }
 std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman) { return std::make_unique<coinjoin::CoinJoinLoaderImpl>(walletman); }
diff --git a/src/interfaces/coinjoin.h b/src/interfaces/coinjoin.h
index be8d36849db9..a332f55dd30f 100644
--- a/src/interfaces/coinjoin.h
+++ b/src/interfaces/coinjoin.h
@@ -36,12 +36,12 @@ class Loader
     virtual void AddWallet(CWallet&) = 0;
     //! Remove wallet from CoinJoin client manager
     virtual void RemoveWallet(const std::string&) = 0;
-    virtual void FlushWallet(const CWallet&) = 0;
-    virtual std::unique_ptr<CoinJoin::Client> GetClient(const CWallet& wallet) = 0;
+    virtual void FlushWallet(const std::string&) = 0;
+    virtual std::unique_ptr<CoinJoin::Client> GetClient(const std::string&) = 0;
 };
 } // namespace CoinJoin
 
-std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const CWallet& wallet);
+std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const std::string& name);
 std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman);
 
 } // namespace interfaces
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index aeeb8f8d83d0..c18170e1cf22 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -51,7 +51,7 @@ static UniValue coinjoin(const JSONRPCRequest& request)
         }
     }
 
-    auto cj_clientman = ::coinJoinWalletManager->Get(*wallet);
+    auto cj_clientman = ::coinJoinWalletManager->Get(wallet->GetName());
     CHECK_NONFATAL(cj_clientman != nullptr);
 
     if (request.params[0].get_str() == "start") {
@@ -163,7 +163,7 @@ static UniValue getcoinjoininfo(const JSONRPCRequest& request)
         return obj;
     }
 
-    auto manager = ::coinJoinWalletManager->Get(*wallet);
+    auto manager = ::coinJoinWalletManager->Get(wallet->GetName());
     CHECK_NONFATAL(manager != nullptr);
     manager->GetJsonInfo(obj);
 
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index 177fa94c650c..aa783cfd3fff 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -207,7 +207,7 @@ void WalletInit::InitCoinJoinSettings(const CoinJoinWalletManager& cjwalletman)
     }
     bool fAutoStart = gArgs.GetBoolArg("-coinjoinautostart", DEFAULT_COINJOIN_AUTOSTART);
     for (auto& pwallet : GetWallets()) {
-        auto manager = cjwalletman.Get(*pwallet);
+        auto manager = cjwalletman.Get(pwallet->GetName());
         assert(manager != nullptr);
         if (pwallet->IsLocked()) {
             manager->StopMixing();
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index abc3d75114e7..58d93ec293d7 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -506,7 +506,7 @@ class WalletImpl : public Wallet
     bool privateKeysDisabled() override { return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS); }
     interfaces::CoinJoin::Client& coinJoin() override
     {
-        if (m_coinjoin_client == nullptr) m_coinjoin_client = interfaces::MakeCoinJoinClient(m_cjwalletman, *m_wallet);
+        if (m_coinjoin_client == nullptr) m_coinjoin_client = interfaces::MakeCoinJoinClient(m_cjwalletman, m_wallet->GetName());
         return *m_coinjoin_client;
     }
     CAmount getDefaultMaxTxFee() override { return m_wallet->m_default_max_tx_fee; }
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 7f8cdb37ebb8..1617d9aa1d75 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -141,7 +141,7 @@ void FlushWallets()
     for (const std::shared_ptr<CWallet>& pwallet : GetWallets()) {
         if (CCoinJoinClientOptions::IsEnabled()) {
             // Stop CoinJoin, release keys
-            pwallet->coinjoin_loader().FlushWallet(*pwallet);
+            pwallet->coinjoin_loader().FlushWallet(pwallet->GetName());
         }
         pwallet->Flush();
     }
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index f165af8c5f65..ce5848bf7c33 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1632,7 +1632,7 @@ void CWallet::NewKeyPoolCallback()
 {
     // Note: GetClient(*this) can return nullptr when this wallet is in the middle of its creation.
     // Skipping stopMixing() is fine in this case.
-    if (std::unique_ptr<interfaces::CoinJoin::Client> coinjoin_client = coinjoin_loader().GetClient(*this)) {
+    if (std::unique_ptr<interfaces::CoinJoin::Client> coinjoin_client = coinjoin_loader().GetClient(GetName())) {
         coinjoin_client->stopMixing();
     }
     nKeysLeftSinceAutoBackup = 0;

From 7fd30b5203313fb989452981fd6e166f601c23a3 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Tue, 2 Jan 2024 02:34:53 +0300
Subject: [PATCH 17/22] refactor: use coinjoin interfaces in qt

---
 src/interfaces/node.h    |  6 ++++++
 src/node/interfaces.cpp  |  2 ++
 src/qt/bitcoingui.cpp    |  3 ++-
 src/qt/optionsdialog.cpp |  3 ++-
 src/qt/overviewpage.cpp  | 35 ++++++++++++++++++-----------------
 src/qt/walletmodel.cpp   |  6 ++++++
 src/qt/walletmodel.h     |  5 ++++-
 7 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index 93aa556bed01..f837fdbd45ca 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -39,6 +39,9 @@ struct NodeContext;
 namespace interfaces {
 class Handler;
 class WalletLoader;
+namespace CoinJoin {
+class Loader;
+} //namespsace CoinJoin
 struct BlockTip;
 
 //! Interface for the src/evo part of a dash node (dashd process).
@@ -303,6 +306,9 @@ class Node
     //! Return interface for accessing coinjoin related handler.
     virtual CoinJoin::Options& coinJoinOptions() = 0;
 
+    //! Return interface for accessing coinjoin loader handler.
+    virtual std::unique_ptr<interfaces::CoinJoin::Loader>& coinJoinLoader() = 0;
+
     //! Register handler for init messages.
     using InitMessageFn = std::function<void(const std::string& message)>;
     virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 29c3a510d727..41447b2ed478 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -15,6 +15,7 @@
 #include <governance/object.h>
 #include <init.h>
 #include <interfaces/chain.h>
+#include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
 #include <llmq/chainlocks.h>
@@ -451,6 +452,7 @@ class NodeImpl : public Node
     LLMQ& llmq() override { return m_llmq; }
     Masternode::Sync& masternodeSync() override { return m_masternodeSync; }
     CoinJoin::Options& coinJoinOptions() override { return m_coinjoin; }
+    std::unique_ptr<interfaces::CoinJoin::Loader>& coinJoinLoader() override { return m_context->coinjoin_loader; }
 
     std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
     {
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 890df6c03237..2d6cad3bf719 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -33,6 +33,7 @@
 #include <functional>
 #include <chain.h>
 #include <chainparams.h>
+#include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <qt/governancelist.h>
@@ -1379,7 +1380,7 @@ void BitcoinGUI::setNumBlocks(int count, const QDateTime& blockDate, const QStri
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         for (const auto& wallet : m_node.walletLoader().getWallets()) {
-            disableAppNap |= wallet->coinJoin().isMixing();
+            disableAppNap |= m_node.coinJoinLoader()->GetClient(wallet->getWalletName())->isMixing();
         }
     }
 #endif // ENABLE_WALLET
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
index e52d650bde9b..bafc6127b4a1 100644
--- a/src/qt/optionsdialog.cpp
+++ b/src/qt/optionsdialog.cpp
@@ -15,6 +15,7 @@
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 
+#include <interfaces/coinjoin.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <validation.h> // for DEFAULT_SCRIPTCHECK_THREADS and MAX_SCRIPTCHECK_THREADS
@@ -411,7 +412,7 @@ void OptionsDialog::on_okButton_clicked()
 #ifdef ENABLE_WALLET
     if (m_enable_wallet) {
         for (auto& wallet : model->node().walletLoader().getWallets()) {
-            wallet->coinJoin().resetCachedBlocks();
+            model->node().coinJoinLoader()->GetClient(wallet->getWalletName())->resetCachedBlocks();
             wallet->markDirty();
         }
     }
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
index 40bb4adcac36..682ebb5d9ea5 100644
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -16,6 +16,7 @@
 #include <qt/walletmodel.h>
 
 #include <coinjoin/options.h>
+#include <interfaces/coinjoin.h>
 
 #include <cmath>
 
@@ -306,7 +307,7 @@ void OverviewPage::setWalletModel(WalletModel *model)
 
         // Disable coinJoinClient builtin support for automatic backups while we are in GUI,
         // we'll handle automatic backups and user warnings in coinJoinStatus()
-        walletModel->coinJoin().disableAutobackups();
+        walletModel->coinJoin()->disableAutobackups();
 
         connect(ui->toggleCoinJoin, &QPushButton::clicked, this, &OverviewPage::toggleCoinJoin);
 
@@ -523,7 +524,7 @@ void OverviewPage::coinJoinStatus(bool fForce)
     int nBestHeight = clientModel->node().getNumBlocks();
 
     // We are processing more than 1 block per second, we'll just leave
-    if (nBestHeight > walletModel->coinJoin().getCachedBlocks() && GetTime() - nLastDSProgressBlockTime <= 1) return;
+    if (nBestHeight > walletModel->coinJoin()->getCachedBlocks() && GetTime() - nLastDSProgressBlockTime <= 1) return;
     nLastDSProgressBlockTime = GetTime();
 
     QString strKeysLeftText(tr("keys left: %1").arg(walletModel->getKeysLeftSinceAutoBackup()));
@@ -533,9 +534,9 @@ void OverviewPage::coinJoinStatus(bool fForce)
     ui->labelCoinJoinEnabled->setToolTip(strKeysLeftText);
 
     QString strCoinJoinName = QString::fromStdString(gCoinJoinName);
-    if (!walletModel->coinJoin().isMixing()) {
-        if (nBestHeight != walletModel->coinJoin().getCachedBlocks()) {
-            walletModel->coinJoin().setCachedBlocks(nBestHeight);
+    if (!walletModel->coinJoin()->isMixing()) {
+        if (nBestHeight != walletModel->coinJoin()->getCachedBlocks()) {
+            walletModel->coinJoin()->setCachedBlocks(nBestHeight);
             updateCoinJoinProgress();
         }
 
@@ -596,7 +597,7 @@ void OverviewPage::coinJoinStatus(bool fForce)
         }
     }
 
-    QString strEnabled = walletModel->coinJoin().isMixing() ? tr("Enabled") : tr("Disabled");
+    QString strEnabled = walletModel->coinJoin()->isMixing() ? tr("Enabled") : tr("Disabled");
     // Show how many keys left in advanced PS UI mode only
     if(fShowAdvancedCJUI) strEnabled += ", " + strKeysLeftText;
     ui->labelCoinJoinEnabled->setText(strEnabled);
@@ -618,15 +619,15 @@ void OverviewPage::coinJoinStatus(bool fForce)
     }
 
     // check coinjoin status and unlock if needed
-    if(nBestHeight != walletModel->coinJoin().getCachedBlocks()) {
+    if(nBestHeight != walletModel->coinJoin()->getCachedBlocks()) {
         // Balance and number of transactions might have changed
-        walletModel->coinJoin().setCachedBlocks(nBestHeight);
+        walletModel->coinJoin()->setCachedBlocks(nBestHeight);
         updateCoinJoinProgress();
     }
 
     setWidgetsVisible(true);
 
-    ui->labelSubmittedDenom->setText(QString(walletModel->coinJoin().getSessionDenoms().c_str()));
+    ui->labelSubmittedDenom->setText(QString(walletModel->coinJoin()->getSessionDenoms().c_str()));
 }
 
 void OverviewPage::toggleCoinJoin(){
@@ -641,7 +642,7 @@ void OverviewPage::toggleCoinJoin(){
         settings.setValue("hasMixed", "hasMixed");
     }
 
-    if (!walletModel->coinJoin().isMixing()) {
+    if (!walletModel->coinJoin()->isMixing()) {
         auto& options = walletModel->node().coinJoinOptions();
         const CAmount nMinAmount = options.getSmallestDenomination() + options.getMaxCollateralAmount();
         if(m_balances.balance < nMinAmount) {
@@ -659,7 +660,7 @@ void OverviewPage::toggleCoinJoin(){
             if(!ctx.isValid())
             {
                 //unlock was cancelled
-                walletModel->coinJoin().resetCachedBlocks();
+                walletModel->coinJoin()->resetCachedBlocks();
                 QMessageBox::warning(this, strCoinJoinName,
                     tr("Wallet is locked and user declined to unlock. Disabling %1.").arg(strCoinJoinName),
                     QMessageBox::Ok, QMessageBox::Ok);
@@ -670,15 +671,15 @@ void OverviewPage::toggleCoinJoin(){
 
     }
 
-    walletModel->coinJoin().resetCachedBlocks();
+    walletModel->coinJoin()->resetCachedBlocks();
 
-    if (walletModel->coinJoin().isMixing()) {
+    if (walletModel->coinJoin()->isMixing()) {
         ui->toggleCoinJoin->setText(tr("Start %1").arg(strCoinJoinName));
-        walletModel->coinJoin().resetPool();
-        walletModel->coinJoin().stopMixing();
+        walletModel->coinJoin()->resetPool();
+        walletModel->coinJoin()->stopMixing();
     } else {
         ui->toggleCoinJoin->setText(tr("Stop %1").arg(strCoinJoinName));
-        walletModel->coinJoin().startMixing();
+        walletModel->coinJoin()->startMixing();
     }
 }
 
@@ -718,5 +719,5 @@ void OverviewPage::DisableCoinJoinCompletely()
     if (nWalletBackups <= 0) {
         ui->labelCoinJoinEnabled->setText("<span style='" + GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_ERROR) + "'>(" + tr("Disabled") + ")</span>");
     }
-    walletModel->coinJoin().stopMixing();
+    walletModel->coinJoin()->stopMixing();
 }
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index d7c11f1327b1..049fba2f40eb 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -17,6 +17,7 @@
 #include <qt/recentrequeststablemodel.h>
 #include <qt/transactiontablemodel.h>
 
+#include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <key_io.h>
@@ -77,6 +78,11 @@ void WalletModel::setClientModel(ClientModel* client_model)
     if (!m_client_model) timer->stop();
 }
 
+std::unique_ptr<interfaces::CoinJoin::Client> WalletModel::coinJoin() const
+{
+    return m_node.coinJoinLoader()->GetClient(m_wallet->getWalletName());
+}
+
 void WalletModel::updateStatus()
 {
     EncryptionStatus newEncryptionStatus = getEncryptionStatus();
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 9d385f8a3e96..b2a31b82b1be 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -38,6 +38,9 @@ class uint256;
 
 namespace interfaces {
 class Node;
+namespace CoinJoin {
+class Client;
+} // namespace CoinJoin
 } // namespace interfaces
 
 QT_BEGIN_NAMESPACE
@@ -151,7 +154,7 @@ class WalletModel : public QObject
     interfaces::Node& node() const { return m_node; }
     interfaces::Wallet& wallet() const { return *m_wallet; }
     void setClientModel(ClientModel* client_model);
-    interfaces::CoinJoin::Client& coinJoin() const { return m_wallet->coinJoin(); }
+    std::unique_ptr<interfaces::CoinJoin::Client> coinJoin() const;
 
     QString getWalletName() const;
     QString getDisplayName() const;

From dc5152bd7417679eda06b5d4107a195a305fa361 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Tue, 2 Jan 2024 18:28:46 +0300
Subject: [PATCH 18/22] refactor: drop global coinJoinWalletManager

---
 src/coinjoin/client.cpp             |  2 --
 src/coinjoin/client.h               |  3 ---
 src/coinjoin/context.cpp            | 16 +++-------------
 src/coinjoin/context.h              |  3 ++-
 src/coinjoin/interfaces.cpp         | 12 ++++++------
 src/interfaces/coinjoin.h           |  2 +-
 src/interfaces/node.h               |  2 +-
 src/interfaces/wallet.h             |  6 +++---
 src/rpc/coinjoin.cpp                |  7 ++++---
 src/test/util/setup_common.cpp      |  2 +-
 src/wallet/interfaces.cpp           | 10 ++--------
 src/wallet/test/coinjoin_tests.cpp  |  5 +++--
 src/wallet/test/init_test_fixture.h |  1 +
 src/wallet/test/wallet_tests.cpp    |  5 +++--
 14 files changed, 30 insertions(+), 46 deletions(-)

diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 4be282e2accc..bf9776103f80 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -29,8 +29,6 @@
 #include <memory>
 #include <univalue.h>
 
-std::unique_ptr<CoinJoinWalletManager> coinJoinWalletManager;
-
 void CCoinJoinClientQueueManager::ProcessMessage(const CNode& peer, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv)
 {
     if (fMasternodeMode) return;
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 82e1e04fd4dc..1536c58af932 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -29,9 +29,6 @@ class UniValue;
 
 using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
 
-// The main object for accessing mixing
-extern std::unique_ptr<CoinJoinWalletManager> coinJoinWalletManager;
-
 class CPendingDsaRequest
 {
 private:
diff --git a/src/coinjoin/context.cpp b/src/coinjoin/context.cpp
index 294cbb1f7e58..b0ffe893ac78 100644
--- a/src/coinjoin/context.cpp
+++ b/src/coinjoin/context.cpp
@@ -5,8 +5,8 @@
 #include <coinjoin/context.h>
 
 #include <net.h>
-#include <policy/fees.h>
 #include <txmempool.h>
+#include <validation.h>
 
 #ifdef ENABLE_WALLET
 #include <coinjoin/client.h>
@@ -15,20 +15,10 @@
 
 CJContext::CJContext(CChainState& chainstate, CConnman& connman, CTxMemPool& mempool, const CMasternodeSync& mn_sync, bool relay_txes) :
 #ifdef ENABLE_WALLET
-    walletman {
-        [&]() -> CoinJoinWalletManager* const {
-            assert(::coinJoinWalletManager == nullptr);
-            ::coinJoinWalletManager = std::make_unique<CoinJoinWalletManager>(connman, mempool, mn_sync, queueman);
-            return ::coinJoinWalletManager.get();
-        }()
-    },
+    walletman{std::make_unique<CoinJoinWalletManager>(connman, mempool, mn_sync, queueman)},
     queueman {relay_txes ? std::make_unique<CCoinJoinClientQueueManager>(connman, *walletman, mn_sync) : nullptr},
 #endif // ENABLE_WALLET
     server{std::make_unique<CCoinJoinServer>(chainstate, connman, mempool, mn_sync)}
 {}
 
-CJContext::~CJContext() {
-#ifdef ENABLE_WALLET
-    ::coinJoinWalletManager.reset();
-#endif // ENABLE_WALLET
-}
+CJContext::~CJContext() {}
diff --git a/src/coinjoin/context.h b/src/coinjoin/context.h
index 7f2fc4f79bf1..0a0c9d908e00 100644
--- a/src/coinjoin/context.h
+++ b/src/coinjoin/context.h
@@ -30,7 +30,8 @@ struct CJContext {
     ~CJContext();
 
 #ifdef ENABLE_WALLET
-    CoinJoinWalletManager* const walletman;
+    // The main object for accessing mixing
+    const std::unique_ptr<CoinJoinWalletManager> walletman;
     const std::unique_ptr<CCoinJoinClientQueueManager> queueman;
 #endif // ENABLE_WALLET
     const std::unique_ptr<CCoinJoinServer> server;
diff --git a/src/coinjoin/interfaces.cpp b/src/coinjoin/interfaces.cpp
index d5058b75bf2a..78a97194319b 100644
--- a/src/coinjoin/interfaces.cpp
+++ b/src/coinjoin/interfaces.cpp
@@ -81,7 +81,12 @@ class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
     }
     std::unique_ptr<interfaces::CoinJoin::Client> GetClient(const std::string& name) override
     {
-        return interfaces::MakeCoinJoinClient(m_walletman, name);
+        auto clientman = m_walletman.Get(name);
+        return clientman ? std::make_unique<CoinJoinClientImpl>(*clientman) : nullptr;
+    }
+    CoinJoinWalletManager& walletman() override
+    {
+        return m_walletman;
     }
 };
 
@@ -89,10 +94,5 @@ class CoinJoinLoaderImpl : public interfaces::CoinJoin::Loader
 } // namespace coinjoin
 
 namespace interfaces {
-std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const std::string& name)
-{
-    auto clientman = walletman.Get(name);
-    return clientman ? std::make_unique<coinjoin::CoinJoinClientImpl>(*clientman) : nullptr;
-}
 std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman) { return std::make_unique<coinjoin::CoinJoinLoaderImpl>(walletman); }
 } // namespace interfaces
diff --git a/src/interfaces/coinjoin.h b/src/interfaces/coinjoin.h
index a332f55dd30f..345780cde0da 100644
--- a/src/interfaces/coinjoin.h
+++ b/src/interfaces/coinjoin.h
@@ -38,10 +38,10 @@ class Loader
     virtual void RemoveWallet(const std::string&) = 0;
     virtual void FlushWallet(const std::string&) = 0;
     virtual std::unique_ptr<CoinJoin::Client> GetClient(const std::string&) = 0;
+    virtual CoinJoinWalletManager& walletman() = 0;
 };
 } // namespace CoinJoin
 
-std::unique_ptr<CoinJoin::Client> MakeCoinJoinClient(const CoinJoinWalletManager& walletman, const std::string& name);
 std::unique_ptr<CoinJoin::Loader> MakeCoinJoinLoader(CoinJoinWalletManager& walletman);
 
 } // namespace interfaces
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index f837fdbd45ca..8ca91dc8af43 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -303,7 +303,7 @@ class Node
     //! Return interface for accessing masternode related handler.
     virtual Masternode::Sync& masternodeSync() = 0;
 
-    //! Return interface for accessing coinjoin related handler.
+    //! Return interface for accessing coinjoin options related handler.
     virtual CoinJoin::Options& coinJoinOptions() = 0;
 
     //! Return interface for accessing coinjoin loader handler.
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 807cedae9096..82b5b23d9e14 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -8,7 +8,6 @@
 #include <amount.h>                    // For CAmount
 #include <fs.h>                        // For fs::path
 #include <interfaces/chain.h>          // For ChainClient
-#include <interfaces/coinjoin.h>       // For CoinJoin::*
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
@@ -48,6 +47,9 @@ struct WalletBalances;
 struct WalletTx;
 struct WalletTxOut;
 struct WalletTxStatus;
+namespace CoinJoin {
+class Loader;
+}
 
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
@@ -278,8 +280,6 @@ class Wallet
     // Return whether private keys enabled.
     virtual bool privateKeysDisabled() = 0;
 
-    virtual CoinJoin::Client& coinJoin() = 0;
-
     //! Get max tx fee.
     virtual CAmount getDefaultMaxTxFee() = 0;
 
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index c18170e1cf22..b584a7853587 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -14,6 +14,7 @@
 #ifdef ENABLE_WALLET
 #include <coinjoin/client.h>
 #include <coinjoin/options.h>
+#include <interfaces/coinjoin.h>
 #include <wallet/rpcwallet.h>
 #endif // ENABLE_WALLET
 
@@ -51,7 +52,8 @@ static UniValue coinjoin(const JSONRPCRequest& request)
         }
     }
 
-    auto cj_clientman = ::coinJoinWalletManager->Get(wallet->GetName());
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    auto cj_clientman = node.coinjoin_loader->walletman().Get(wallet->GetName());
     CHECK_NONFATAL(cj_clientman != nullptr);
 
     if (request.params[0].get_str() == "start") {
@@ -65,7 +67,6 @@ static UniValue coinjoin(const JSONRPCRequest& request)
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Mixing has been started already.");
         }
 
-        const NodeContext& node = EnsureAnyNodeContext(request.context);
         CTxMemPool& mempool = EnsureMemPool(node);
         CBlockPolicyEstimator& fee_estimator = EnsureFeeEstimator(node);
         bool result = cj_clientman->DoAutomaticDenominating(*node.connman, fee_estimator, mempool);
@@ -163,7 +164,7 @@ static UniValue getcoinjoininfo(const JSONRPCRequest& request)
         return obj;
     }
 
-    auto manager = ::coinJoinWalletManager->Get(wallet->GetName());
+    auto manager = node.coinjoin_loader->walletman().Get(wallet->GetName());
     CHECK_NONFATAL(manager != nullptr);
     manager->GetJsonInfo(obj);
 
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 5cd818cb3821..5bec88ccd479 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -110,7 +110,7 @@ void DashTestSetup(NodeContext& node)
 
     node.cj_ctx = std::make_unique<CJContext>(chainstate, *node.connman, *node.mempool, *::masternodeSync, /* relay_txes */ true);
 #ifdef ENABLE_WALLET
-    node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*::coinJoinWalletManager);
+    node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*node.cj_ctx->walletman);
 #endif // ENABLE_WALLET
     ::deterministicMNManager = std::make_unique<CDeterministicMNManager>(chainstate, *node.connman, *node.evodb);
     node.llmq_ctx = std::make_unique<LLMQContext>(chainstate, *node.connman, *node.evodb, *sporkManager, *node.mempool, node.peerman, true, false);
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 58d93ec293d7..84d09a95defd 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -124,7 +124,7 @@ WalletTxOut MakeWalletTxOut(const CWallet& wallet,
 class WalletImpl : public Wallet
 {
 public:
-    explicit WalletImpl(const std::shared_ptr<CWallet>& wallet, CoinJoinWalletManager& cjwalletman) : m_wallet(wallet), m_cjwalletman(cjwalletman) {}
+    explicit WalletImpl(const std::shared_ptr<CWallet>& wallet) : m_wallet(wallet) {}
 
     void markDirty() override
     {
@@ -504,11 +504,6 @@ class WalletImpl : public Wallet
     bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
     bool canGetAddresses() override { return m_wallet->CanGetAddresses(); }
     bool privateKeysDisabled() override { return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS); }
-    interfaces::CoinJoin::Client& coinJoin() override
-    {
-        if (m_coinjoin_client == nullptr) m_coinjoin_client = interfaces::MakeCoinJoinClient(m_cjwalletman, m_wallet->GetName());
-        return *m_coinjoin_client;
-    }
     CAmount getDefaultMaxTxFee() override { return m_wallet->m_default_max_tx_fee; }
     void remove() override
     {
@@ -558,7 +553,6 @@ class WalletImpl : public Wallet
     CWallet* wallet() override { return m_wallet.get(); }
 
     std::shared_ptr<CWallet> m_wallet;
-    CoinJoinWalletManager& m_cjwalletman;
     std::unique_ptr<interfaces::CoinJoin::Client> m_coinjoin_client;
 };
 
@@ -644,7 +638,7 @@ class WalletLoaderImpl : public WalletLoader
 } // namespace wallet
 
 namespace interfaces {
-std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet, *::coinJoinWalletManager) : nullptr; }
+std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(wallet) : nullptr; }
 std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, ArgsManager& args) {
     return std::make_unique<wallet::WalletLoaderImpl>(chain, coinjoin_loader, args);
 }
diff --git a/src/wallet/test/coinjoin_tests.cpp b/src/wallet/test/coinjoin_tests.cpp
index 14cb45c670c8..eac311c46b14 100644
--- a/src/wallet/test/coinjoin_tests.cpp
+++ b/src/wallet/test/coinjoin_tests.cpp
@@ -7,6 +7,7 @@
 #include <amount.h>
 #include <coinjoin/client.h>
 #include <coinjoin/coinjoin.h>
+#include <coinjoin/context.h>
 #include <coinjoin/options.h>
 #include <coinjoin/util.h>
 #include <node/context.h>
@@ -207,8 +208,8 @@ class CTransactionBuilderTestSetup : public TestChain100Setup
 
 BOOST_FIXTURE_TEST_CASE(coinjoin_manager_start_stop_tests, CTransactionBuilderTestSetup)
 {
-    BOOST_CHECK_EQUAL(::coinJoinWalletManager->raw().size(), 1);
-    auto& cj_man = ::coinJoinWalletManager->raw().begin()->second;
+    BOOST_CHECK_EQUAL(m_node.cj_ctx->walletman->raw().size(), 1);
+    auto& cj_man = m_node.cj_ctx->walletman->raw().begin()->second;
     BOOST_CHECK_EQUAL(cj_man->IsMixing(), false);
     BOOST_CHECK_EQUAL(cj_man->StartMixing(), true);
     BOOST_CHECK_EQUAL(cj_man->IsMixing(), true);
diff --git a/src/wallet/test/init_test_fixture.h b/src/wallet/test/init_test_fixture.h
index 449b99582142..cb1349bac20b 100644
--- a/src/wallet/test/init_test_fixture.h
+++ b/src/wallet/test/init_test_fixture.h
@@ -6,6 +6,7 @@
 #define BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H
 
 #include <interfaces/chain.h>
+#include <interfaces/coinjoin.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <test/util/setup_common.h>
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index dc182fb4d7fe..c117ac6ec280 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -11,7 +11,9 @@
 #include <vector>
 
 #include <coinjoin/client.h>
+#include <coinjoin/context.h>
 #include <interfaces/chain.h>
+#include <interfaces/coinjoin.h>
 #include <key_io.h>
 #include <node/context.h>
 #include <policy/policy.h>
@@ -1335,8 +1337,7 @@ static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
     node.fee_estimator = std::make_unique<CBlockPolicyEstimator>();
     node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get());
     auto chain = interfaces::MakeChain(node);
-    auto coinjoin_loader = interfaces::MakeCoinJoinLoader(*::coinJoinWalletManager);
-    CWallet wallet(chain.get(), coinjoin_loader, "", CreateDummyWalletDatabase());
+    CWallet wallet(chain.get(), /*coinjoin_loader=*/ nullptr, "", CreateDummyWalletDatabase());
     AddKey(wallet, key);
     auto spk_man = wallet.GetLegacyScriptPubKeyMan();
     spk_man->AddCScript(inner_script);

From 09207a454a8ca765a10de8629b0154137477dfa1 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Sun, 7 Jan 2024 03:50:02 +0700
Subject: [PATCH 19/22] fix: removed unused variables from wallet_tests

---
 src/wallet/test/wallet_tests.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index c117ac6ec280..27575c9e270c 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -621,7 +621,6 @@ class ListCoinsTestingSetup : public TestChain100Setup
     }
 
     std::unique_ptr<CWallet> wallet;
-    std::unique_ptr<interfaces::CoinJoin::Loader> coinjoin_loader;
 };
 
 BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
@@ -731,7 +730,6 @@ class CreateTransactionTestSetup : public TestChain100Setup
         RemoveWallet(wallet, std::nullopt);
     }
 
-    std::unique_ptr<interfaces::CoinJoin::Loader> coinjoin_loader;
     std::shared_ptr<CWallet> wallet;
     CCoinControl coinControl;
 

From 0964068a2f5c00ec847f15611818539ed1553eec Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Sun, 7 Jan 2024 22:09:56 +0700
Subject: [PATCH 20/22] refactor: working with raw pointer of coinjoin_loader
 instead reference to unique_ptr

---
 src/bench/wallet_balance.cpp            |  2 +-
 src/qt/test/addressbooktests.cpp        |  2 +-
 src/qt/test/wallettests.cpp             |  2 +-
 src/wallet/interfaces.cpp               |  6 +++---
 src/wallet/load.cpp                     |  2 +-
 src/wallet/load.h                       |  3 +--
 src/wallet/rpcwallet.cpp                |  4 ++--
 src/wallet/test/coinjoin_tests.cpp      |  2 +-
 src/wallet/test/wallet_test_fixture.cpp |  2 +-
 src/wallet/test/wallet_tests.cpp        | 26 ++++++++++++-------------
 src/wallet/wallet.cpp                   | 13 ++++++-------
 src/wallet/wallet.h                     | 12 ++++++------
 12 files changed, 37 insertions(+), 39 deletions(-)

diff --git a/src/bench/wallet_balance.cpp b/src/bench/wallet_balance.cpp
index be9964cd1cc3..8f0264b72c24 100644
--- a/src/bench/wallet_balance.cpp
+++ b/src/bench/wallet_balance.cpp
@@ -24,7 +24,7 @@ static void WalletBalance(benchmark::Bench& bench, const bool set_dirty, const b
     };
     const auto& ADDRESS_WATCHONLY = ADDRESS_B58T_UNSPENDABLE;
 
-    CWallet wallet{test_setup.m_node.chain.get(), test_setup.m_node.coinjoin_loader, "", CreateMockWalletDatabase()};
+    CWallet wallet{test_setup.m_node.chain.get(), test_setup.m_node.coinjoin_loader.get(), "", CreateMockWalletDatabase()};
     {
         wallet.SetupLegacyScriptPubKeyMan();
         bool first_run;
diff --git a/src/qt/test/addressbooktests.cpp b/src/qt/test/addressbooktests.cpp
index a4b3c30103d0..4c11b165142a 100644
--- a/src/qt/test/addressbooktests.cpp
+++ b/src/qt/test/addressbooktests.cpp
@@ -60,7 +60,7 @@ void TestAddAddressesToSendBook(interfaces::Node& node)
 {
     TestChain100Setup test;
     node.setContext(&test.m_node);
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), node.context()->coinjoin_loader, "", CreateMockWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), node.context()->coinjoin_loader.get(), "", CreateMockWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     bool firstRun;
     wallet->LoadWallet(firstRun);
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index 0b6ab7058690..d948276aa22c 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -108,7 +108,7 @@ void TestGUI(interfaces::Node& node)
         test.CreateAndProcessBlock({}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
     }
     node.setContext(&test.m_node);
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), node.context()->coinjoin_loader, "", CreateMockWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(node.context()->chain.get(), node.context()->coinjoin_loader.get(), "", CreateMockWalletDatabase());
     AddWallet(wallet);
     bool firstRun;
     wallet->LoadWallet(firstRun);
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 84d09a95defd..e6acbd0c1000 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -578,7 +578,7 @@ class WalletLoaderImpl : public WalletLoader
         }
     }
     bool verify() override { return VerifyWallets(*m_context.chain); }
-    bool load() override { assert(m_context.m_coinjoin_loader); return LoadWallets(*m_context.chain, m_context.m_coinjoin_loader); }
+    bool load() override { assert(m_context.m_coinjoin_loader); return LoadWallets(*m_context.chain, *m_context.m_coinjoin_loader); }
     void start(CScheduler& scheduler) override { return StartWallets(scheduler, *Assert(m_context.args)); }
     void flush() override { return FlushWallets(); }
     void stop() override { return StopWallets(); }
@@ -594,7 +594,7 @@ class WalletLoaderImpl : public WalletLoader
         options.create_flags = wallet_creation_flags;
         options.create_passphrase = passphrase;
         assert(m_context.m_coinjoin_loader);
-        return MakeWallet(CreateWallet(*m_context.chain, m_context.m_coinjoin_loader, name, true /* load_on_start */, options, status, error, warnings));
+        return MakeWallet(CreateWallet(*m_context.chain, *m_context.m_coinjoin_loader, name, true /* load_on_start */, options, status, error, warnings));
     }
     std::unique_ptr<Wallet> loadWallet(const std::string& name, bilingual_str& error, std::vector<bilingual_str>& warnings) override
     {
@@ -602,7 +602,7 @@ class WalletLoaderImpl : public WalletLoader
         DatabaseStatus status;
         options.require_existing = true;
         assert(m_context.m_coinjoin_loader);
-        return MakeWallet(LoadWallet(*m_context.chain, m_context.m_coinjoin_loader, name, true /* load_on_start */, options, status, error, warnings));
+        return MakeWallet(LoadWallet(*m_context.chain, *m_context.m_coinjoin_loader, name, true /* load_on_start */, options, status, error, warnings));
     }
     std::string getWalletDir() override
     {
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 1617d9aa1d75..5a11e9bc60ab 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -90,7 +90,7 @@ bool VerifyWallets(interfaces::Chain& chain)
     return true;
 }
 
-bool LoadWallets(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader)
+bool LoadWallets(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader)
 {
     try {
         std::set<fs::path> wallet_paths;
diff --git a/src/wallet/load.h b/src/wallet/load.h
index 23167bf5f2f9..3f952a26e361 100644
--- a/src/wallet/load.h
+++ b/src/wallet/load.h
@@ -6,7 +6,6 @@
 #ifndef BITCOIN_WALLET_LOAD_H
 #define BITCOIN_WALLET_LOAD_H
 
-#include <memory>
 #include <string>
 #include <vector>
 
@@ -25,7 +24,7 @@ class Loader;
 bool VerifyWallets(interfaces::Chain& chain);
 
 //! Load wallet databases.
-bool LoadWallets(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader);
+bool LoadWallets(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader);
 
 //! Complete startup of wallets.
 void StartWallets(CScheduler& scheduler, const ArgsManager& args);
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 74492b593f2c..912d911a7bbd 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -2805,7 +2805,7 @@ static UniValue loadwallet(const JSONRPCRequest& request)
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     std::optional<bool> load_on_start = request.params[1].isNull() ? std::nullopt : std::optional<bool>(request.params[1].get_bool());
-    std::shared_ptr<CWallet> const wallet = LoadWallet(*context.chain, context.m_coinjoin_loader, name, load_on_start, options, status, error, warnings);
+    std::shared_ptr<CWallet> const wallet = LoadWallet(*context.chain, *context.m_coinjoin_loader, name, load_on_start, options, status, error, warnings);
     if (!wallet) {
         // Map bad format to not found, since bad format is returned when the
         // wallet directory exists, but doesn't contain a data file.
@@ -2954,7 +2954,7 @@ static UniValue createwallet(const JSONRPCRequest& request)
     options.create_passphrase = passphrase;
     bilingual_str error;
     std::optional<bool> load_on_start = request.params[5].isNull() ? std::nullopt : std::optional<bool>(request.params[5].get_bool());
-    std::shared_ptr<CWallet> wallet = CreateWallet(*context.chain, context.m_coinjoin_loader, request.params[0].get_str(), load_on_start, options, status, error, warnings);
+    std::shared_ptr<CWallet> wallet = CreateWallet(*context.chain, *context.m_coinjoin_loader, request.params[0].get_str(), load_on_start, options, status, error, warnings);
     if (!wallet) {
         RPCErrorCode code = status == DatabaseStatus::FAILED_ENCRYPT ? RPC_WALLET_ENCRYPTION_FAILED : RPC_WALLET_ERROR;
         throw JSONRPCError(code, error.original);
diff --git a/src/wallet/test/coinjoin_tests.cpp b/src/wallet/test/coinjoin_tests.cpp
index eac311c46b14..39482bd687d4 100644
--- a/src/wallet/test/coinjoin_tests.cpp
+++ b/src/wallet/test/coinjoin_tests.cpp
@@ -130,7 +130,7 @@ class CTransactionBuilderTestSetup : public TestChain100Setup
     CTransactionBuilderTestSetup()
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
-        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
+        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateMockWalletDatabase());
         wallet->SetupLegacyScriptPubKeyMan();
         bool firstRun;
         wallet->LoadWallet(firstRun);
diff --git a/src/wallet/test/wallet_test_fixture.cpp b/src/wallet/test/wallet_test_fixture.cpp
index aefb8349bd30..349797b8cc2b 100644
--- a/src/wallet/test/wallet_test_fixture.cpp
+++ b/src/wallet/test/wallet_test_fixture.cpp
@@ -8,7 +8,7 @@
 WalletTestingSetup::WalletTestingSetup(const std::string& chainName)
     : TestingSetup(chainName),
       m_wallet_loader{interfaces::MakeWalletLoader(*m_node.chain, m_node.coinjoin_loader, *Assert(m_node.args))},
-      m_wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase())
+      m_wallet(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateMockWalletDatabase())
 {
     bool fFirstRun;
     m_wallet.LoadWallet(fFirstRun);
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 27575c9e270c..4f88664d5394 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -52,7 +52,7 @@ static std::shared_ptr<CWallet> TestLoadWallet(NodeContext& node)
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     auto database = MakeWalletDatabase("", options, status, error);
-    auto wallet = CWallet::Create(*node.chain, node.coinjoin_loader, "", std::move(database), options.create_flags, error, warnings);
+    auto wallet = CWallet::Create(*node.chain, *node.coinjoin_loader, "", std::move(database), options.create_flags, error, warnings);
     wallet->postInitProcess();
     return wallet;
 }
@@ -97,7 +97,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 
     // Verify ScanForWalletTransactions fails to read an unknown start block.
     {
-        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         wallet.SetupLegacyScriptPubKeyMan();
         {
             LOCK(wallet.cs_wallet);
@@ -117,7 +117,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
     // Verify ScanForWalletTransactions picks up transactions in both the old
     // and new block files.
     {
-        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -143,7 +143,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
     // Verify ScanForWalletTransactions only picks transactions in the new block
     // file.
     {
-        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -168,7 +168,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 
     // Verify ScanForWalletTransactions scans no blocks.
     {
-        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -204,7 +204,7 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
     // before the missing block, and success for a key whose creation time is
     // after.
     {
-        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         wallet->SetupLegacyScriptPubKeyMan();
         WITH_LOCK(wallet->cs_wallet, wallet->SetLastBlockProcessed(newTip->nHeight, newTip->GetBlockHash()));
         AddWallet(wallet);
@@ -266,7 +266,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
 
     // Import key into wallet and call dumpwallet to create backup file.
     {
-        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         {
             auto spk_man = wallet->GetOrCreateLegacyScriptPubKeyMan();
             LOCK2(wallet->cs_wallet, spk_man->cs_KeyStore);
@@ -289,7 +289,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
     // Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME
     // were scanned, and no prior blocks were scanned.
     {
-        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+        std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
         LOCK(wallet->cs_wallet);
         wallet->SetupLegacyScriptPubKeyMan();
 
@@ -317,7 +317,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
 // Verify getaddressinfo RPC produces more or less expected results
 BOOST_FIXTURE_TEST_CASE(rpc_getaddressinfo, TestChain100Setup)
 {
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateMockWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     AddWallet(wallet);
     CoreContext context{m_node};
@@ -398,7 +398,7 @@ BOOST_FIXTURE_TEST_CASE(rpc_getaddressinfo, TestChain100Setup)
 // debit functions.
 BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
 {
-    CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+    CWallet wallet(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
     auto spk_man = wallet.GetOrCreateLegacyScriptPubKeyMan();
     CWalletTx wtx(&wallet, m_coinbase_txns.back());
 
@@ -573,7 +573,7 @@ class ListCoinsTestingSetup : public TestChain100Setup
     ListCoinsTestingSetup()
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
-        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
+        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateMockWalletDatabase());
         {
             LOCK(wallet->cs_wallet);
             wallet->SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
@@ -710,7 +710,7 @@ class CreateTransactionTestSetup : public TestChain100Setup
     CreateTransactionTestSetup()
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
-        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader, "", CreateMockWalletDatabase());
+        wallet = std::make_unique<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", CreateMockWalletDatabase());
         bool firstRun;
         wallet->LoadWallet(firstRun);
         AddWallet(wallet);
@@ -1191,7 +1191,7 @@ BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)
     node.fee_estimator = std::make_unique<CBlockPolicyEstimator>();
     node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get());
     auto chain = interfaces::MakeChain(node);
-    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(chain.get(), m_node.coinjoin_loader, "", CreateDummyWalletDatabase());
+    std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(chain.get(), m_node.coinjoin_loader.get(), "", CreateDummyWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     wallet->SetMinVersion(FEATURE_LATEST);
     wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index ce5848bf7c33..8426bb9e729d 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -219,7 +219,7 @@ void UnloadWallet(std::shared_ptr<CWallet>&& wallet)
 }
 
 namespace {
-std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
     try {
         std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
@@ -249,7 +249,7 @@ std::shared_ptr<CWallet> LoadWalletInternal(interfaces::Chain& chain, const std:
 }
 } // namespace
 
-std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
     auto result = WITH_LOCK(g_loading_wallet_mutex, return g_loading_wallet_set.insert(name));
     if (!result.second) {
@@ -262,7 +262,7 @@ std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::unique_
     return wallet;
 }
 
-std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
     uint64_t wallet_creation_flags = options.create_flags;
     const SecureString& passphrase = options.create_passphrase;
@@ -4508,9 +4508,8 @@ std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, cons
     return MakeDatabase(wallet_path, options, status, error_string);
 }
 
-std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings)
+std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings)
 {
-    assert(coinjoin_loader);
     const std::string& walletFile = database->Filename();
 
     chain.initMessage(_("Loading wallet...").translated);
@@ -4519,7 +4518,7 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::un
     bool fFirstRun = true;
     // TODO: Can't use std::make_shared because we need a custom deleter but
     // should be possible to use std::allocate_shared.
-    std::shared_ptr<CWallet> walletInstance(new CWallet(&chain, coinjoin_loader, name, std::move(database)), ReleaseWallet);
+    std::shared_ptr<CWallet> walletInstance(new CWallet(&chain, &coinjoin_loader, name, std::move(database)), ReleaseWallet);
     if (!walletInstance->AutoBackupWallet(walletFile, error, warnings) && !error.original.empty()) {
         return nullptr;
     }
@@ -4819,7 +4818,7 @@ std::shared_ptr<CWallet> CWallet::Create(interfaces::Chain& chain, const std::un
         walletInstance->GetDatabase().IncrementUpdateCounter();
     }
 
-    coinjoin_loader->AddWallet(*walletInstance);
+    coinjoin_loader.AddWallet(*walletInstance);
 
     {
         LOCK(cs_wallets);
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index e57b926fd749..775ea04ec622 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -60,8 +60,8 @@ bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> lo
 bool RemoveWallet(const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start);
 std::vector<std::shared_ptr<CWallet>> GetWallets();
 std::shared_ptr<CWallet> GetWallet(const std::string& name);
-std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
-std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
+std::shared_ptr<CWallet> LoadWallet(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
+std::shared_ptr<CWallet> CreateWallet(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
 std::unique_ptr<interfaces::Handler> HandleLoadWallet(LoadWalletFn load_wallet);
 std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error);
 
@@ -760,7 +760,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     interfaces::Chain* m_chain;
 
     /** Interface for accessing CoinJoin state. */
-    const std::unique_ptr<interfaces::CoinJoin::Loader>& m_coinjoin_loader;
+    interfaces::CoinJoin::Loader* m_coinjoin_loader;
 
     /** Wallet name: relative directory name or "" for default wallet. */
     std::string m_name;
@@ -838,7 +838,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     unsigned int nMasterKeyMaxID = 0;
 
     /** Construct wallet with specified name and database implementation. */
-    CWallet(interfaces::Chain* chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database)
+    CWallet(interfaces::Chain* chain, interfaces::CoinJoin::Loader* coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database)
         : fOnlyMixingAllowed(false),
           m_chain(chain),
           m_coinjoin_loader(coinjoin_loader),
@@ -883,7 +883,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     interfaces::Chain& chain() const { assert(m_chain); return *m_chain; }
 
     /** Interface for accessing CoinJoin state. */
-    interfaces::CoinJoin::Loader& coinjoin_loader() { assert(m_coinjoin_loader); return *m_coinjoin_loader.get(); }
+    interfaces::CoinJoin::Loader& coinjoin_loader() { assert(m_coinjoin_loader); return *m_coinjoin_loader; }
 
     const CWalletTx* GetWalletTx(const uint256& hash) const;
 
@@ -1254,7 +1254,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     bool ResendTransaction(const uint256& hashTx);
 
     /* Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error */
-    static std::shared_ptr<CWallet> Create(interfaces::Chain& chain, const std::unique_ptr<interfaces::CoinJoin::Loader>& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings);
+    static std::shared_ptr<CWallet> Create(interfaces::Chain& chain, interfaces::CoinJoin::Loader& coinjoin_loader, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings);
 
     /**
      * Wallet post-init setup

From cd9af42411eecbf5efb14080450b491c59e054a4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 8 Jan 2024 00:36:38 +0700
Subject: [PATCH 21/22] chore: add TODO accordingly init order issue for
 g_wallet_init_interface and WalletContext

---
 src/test/util/setup_common.cpp | 3 +++
 src/wallet/context.h           | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 5bec88ccd479..fdda05357a1f 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -165,6 +165,9 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     InitScriptExecutionCache();
     m_node.addrman = std::make_unique<CAddrMan>();
     m_node.chain = interfaces::MakeChain(m_node);
+    // while g_wallet_init_interface is init here at very early stage
+    // we can't get rid of unique_ptr from wallet/contex.h
+    // TODO: remove unique_ptr from wallet/context.h after bitcoin/bitcoin#22219
     g_wallet_init_interface.Construct(m_node);
     fCheckBlockIndex = true;
     m_node.evodb = std::make_unique<CEvoDB>(1 << 20, true, true);
diff --git a/src/wallet/context.h b/src/wallet/context.h
index 62cc1df98def..059b7f106239 100644
--- a/src/wallet/context.h
+++ b/src/wallet/context.h
@@ -28,6 +28,8 @@ class Loader;
 struct WalletContext {
     interfaces::Chain* chain{nullptr};
     ArgsManager* args{nullptr};
+    // TODO: replace this unique_ptr to a pointer
+    // probably possible to do after bitcoin/bitcoin#22219
     const std::unique_ptr<interfaces::CoinJoin::Loader>& m_coinjoin_loader;
 
     //! Declare default constructor and destructor that are not inline, so code

From 13188e1d9276eebf78a99bbecb5b8d31652c5289 Mon Sep 17 00:00:00 2001
From: "Wladimir J. van der Laan" <laanwj@protonmail.com>
Date: Wed, 1 Jul 2020 15:18:55 +0200
Subject: [PATCH 22/22] Merge #19331: build: Do not include server symbols in
 wallet

faca73000fa8975c28f6be8be01957c1ae94ea62 ci: Install fixed version of clang-format for linters (MarcoFalke)
fa4695da4c69646b58a8fa0b6b30146bb234deb8 build: Sort Makefile.am after renaming file (MarcoFalke)
cccc2784a3bb10fa8e43be7e68207cafb12bd915 scripted-diff: Move ui_interface to the node lib (MarcoFalke)
fa72ca6a9d90d66012765b0043fd819698b94ba8 qt: Remove unused includes (MarcoFalke)
fac96e6450d595fe67168cb7afa7692da6cc9973 wallet: Do not include server symbols (MarcoFalke)
fa0f6c58c1c6d10f04c4e65a424cc51ebca50a8c Revert "Fix link error with --enable-debug" (MarcoFalke)

Pull request description:

  This reverts a hacky workaround from commit b83cc0f, which only happens to work due to compiler optimizations. Then, it actually fixes the linker error.

  The underlying problem is that the wallet includes symbols from the server (ui_interface), which usually results in linker failures. Though, in this specific case the linker failures have not been observed (unless `-O0`) because our compilers were smart enough to strip unused symbols.

  Fix the underlying problem by creating a new header-only with the needed symbol and move ui_interface to node to clarify that this is part of libbitcoin_server.

ACKs for top commit:
  Sjors:
    ACK faca730
  laanwj:
    ACK faca73000fa8975c28f6be8be01957c1ae94ea62
  hebasto:
    re-ACK faca73000fa8975c28f6be8be01957c1ae94ea62, since the [previous](https://github.com/bitcoin/bitcoin/pull/19331#pullrequestreview-434420539) review:

Tree-SHA512: e9731f249425aaea50b6db5fc7622e10078cf006721bb87989cac190a2ff224412f6f8a7dd83efd018835302337611f5839e29e15bef366047ed591cef58dfb4
---
 ci/lint/04_install.sh           |  4 ++++
 src/Makefile.am                 | 35 +++++++++++++++++----------------
 src/banman.cpp                  |  2 +-
 src/bitcoind.cpp                |  2 +-
 src/evo/deterministicmns.cpp    |  1 -
 src/httpserver.cpp              |  2 +-
 src/index/base.cpp              |  2 +-
 src/index/txindex.cpp           |  2 +-
 src/init.cpp                    |  2 +-
 src/interfaces/wallet.h         |  2 +-
 src/llmq/chainlocks.cpp         |  2 +-
 src/masternode/sync.cpp         |  2 +-
 src/net.cpp                     |  2 +-
 src/node/interfaces.cpp         |  2 +-
 src/{ => node}/ui_interface.cpp |  2 +-
 src/{ => node}/ui_interface.h   | 16 ++++-----------
 src/noui.cpp                    |  2 +-
 src/qt/bitcoin.cpp              |  1 -
 src/qt/bitcoingui.cpp           |  2 +-
 src/qt/guiutil.cpp              |  1 -
 src/qt/paymentserver.cpp        |  4 ++--
 src/qt/sendcoinsdialog.cpp      |  2 +-
 src/qt/splashscreen.cpp         |  1 -
 src/qt/transactionview.cpp      |  2 +-
 src/qt/walletmodel.cpp          |  2 +-
 src/qt/walletview.cpp           |  2 +-
 src/shutdown.cpp                |  2 +-
 src/timedata.cpp                |  2 +-
 src/txdb.cpp                    |  2 +-
 src/util/ui_change_type.h       | 15 ++++++++++++++
 src/validation.cpp              |  2 +-
 src/wallet/init.cpp             |  2 +-
 src/wallet/interfaces.cpp       |  2 +-
 src/wallet/wallet.h             |  2 +-
 34 files changed, 68 insertions(+), 60 deletions(-)
 rename src/{ => node}/ui_interface.cpp (99%)
 rename src/{ => node}/ui_interface.h (94%)
 create mode 100644 src/util/ui_change_type.h

diff --git a/ci/lint/04_install.sh b/ci/lint/04_install.sh
index 542c5b52e3fc..e7758a8c5799 100755
--- a/ci/lint/04_install.sh
+++ b/ci/lint/04_install.sh
@@ -6,6 +6,10 @@
 
 export LC_ALL=C
 
+travis_retry sudo apt update && sudo apt install -y clang-format-9
+sudo update-alternatives --install /usr/bin/clang-format      clang-format      $(which clang-format-9     ) 100
+sudo update-alternatives --install /usr/bin/clang-format-diff clang-format-diff $(which clang-format-diff-9) 100
+
 travis_retry pip3 install codespell==1.17.1
 travis_retry pip3 install flake8==3.8.3
 travis_retry pip3 install vulture==2.3
diff --git a/src/Makefile.am b/src/Makefile.am
index 6e416fa1cf6f..2e58ef28ef2f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -141,6 +141,7 @@ BITCOIN_CORE_H = \
   cachemap.h \
   cachemultimap.h \
   blockfilter.h \
+  bloom.h \
   chain.h \
   chainparams.h \
   chainparamsbase.h \
@@ -170,6 +171,7 @@ BITCOIN_CORE_H = \
   cuckoocache.h \
   ctpl_stl.h \
   cxxtimer.hpp \
+  dbwrapper.h \
   deploymentinfo.h \
   deploymentstatus.h \
   evo/assetlocktx.h \
@@ -217,7 +219,6 @@ BITCOIN_CORE_H = \
   interfaces/wallet.h \
   key.h \
   key_io.h \
-  dbwrapper.h \
   limitedmap.h \
   llmq/blockprocessor.h \
   llmq/chainlocks.h \
@@ -263,6 +264,7 @@ BITCOIN_CORE_H = \
   node/context.h \
   node/psbt.h \
   node/transaction.h \
+  node/ui_interface.h \
   node/utxo_snapshot.h \
   noui.h \
   outputtype.h \
@@ -308,13 +310,12 @@ BITCOIN_CORE_H = \
   support/lockedpool.h \
   sync.h \
   timestampindex.h \
-  threadsafety.h \
   threadinterrupt.h \
+  threadsafety.h \
   timedata.h \
   torcontrol.h \
   txdb.h \
   txmempool.h \
-  ui_interface.h \
   undo.h \
   unordered_lru_cache.h \
   util/bip32.h \
@@ -329,8 +330,6 @@ BITCOIN_CORE_H = \
   util/hasher.h \
   util/hash_type.h \
   util/irange.h \
-  util/spanparsing.h \
-  util/system.h \
   util/asmap.h \
   util/getuniquepath.h \
   util/macros.h \
@@ -345,20 +344,22 @@ BITCOIN_CORE_H = \
   util/ranges_set.h \
   util/sock.h \
   util/string.h \
+  util/spanparsing.h \
+  util/system.h \
   util/time.h \
   util/thread.h \
   util/threadnames.h \
   util/trace.h \
   util/translation.h \
-  util/vector.h \
+  util/ui_change_type.h \
   util/url.h \
   util/vector.h \
   validation.h \
   validationinterface.h \
   versionbits.h \
-  walletinitinterface.h \
   wallet/bdb.h \
   wallet/coincontrol.h \
+  wallet/coinselection.h \
   wallet/context.h \
   wallet/crypter.h \
   wallet/db.h \
@@ -373,7 +374,7 @@ BITCOIN_CORE_H = \
   wallet/walletdb.h \
   wallet/wallettool.h \
   wallet/walletutil.h \
-  wallet/coinselection.h \
+  walletinitinterface.h \
   warnings.h \
   zmq/zmqabstractnotifier.h \
   zmq/zmqnotificationinterface.h \
@@ -423,6 +424,14 @@ libbitcoin_server_a_SOURCES = \
   evo/specialtx.cpp \
   evo/specialtxman.cpp \
   flatfile.cpp \
+  governance/classes.cpp \
+  governance/exceptions.cpp \
+  governance/governance.cpp \
+  governance/object.cpp \
+  governance/validators.cpp \
+  governance/vote.cpp \
+  governance/votedb.cpp \
+  gsl/assert.cpp \
   httprpc.cpp \
   httpserver.cpp \
   i2p.cpp \
@@ -431,14 +440,6 @@ libbitcoin_server_a_SOURCES = \
   index/coinstatsindex.cpp \
   index/txindex.cpp \
   init.cpp \
-  governance/governance.cpp \
-  governance/classes.cpp \
-  governance/exceptions.cpp \
-  governance/object.cpp \
-  governance/validators.cpp \
-  governance/vote.cpp \
-  governance/votedb.cpp \
-  gsl/assert.cpp \
   llmq/quorums.cpp \
   llmq/blockprocessor.cpp \
   llmq/commitment.cpp \
@@ -472,6 +473,7 @@ libbitcoin_server_a_SOURCES = \
   node/interfaces.cpp \
   node/psbt.cpp \
   node/transaction.cpp \
+  node/ui_interface.cpp \
   noui.cpp \
   policy/fees.cpp \
   policy/policy.cpp \
@@ -497,7 +499,6 @@ libbitcoin_server_a_SOURCES = \
   torcontrol.cpp \
   txdb.cpp \
   txmempool.cpp \
-  ui_interface.cpp \
   validation.cpp \
   validationinterface.cpp \
   versionbits.cpp \
diff --git a/src/banman.cpp b/src/banman.cpp
index c7e9cb674476..8f216ab8a05f 100644
--- a/src/banman.cpp
+++ b/src/banman.cpp
@@ -6,7 +6,7 @@
 #include <banman.h>
 
 #include <netaddress.h>
-#include <ui_interface.h>
+#include <node/ui_interface.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
index def1807316e8..d56eb01afaf0 100644
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -14,9 +14,9 @@
 #include <init.h>
 #include <interfaces/chain.h>
 #include <node/context.h>
+#include <node/ui_interface.h>
 #include <noui.h>
 #include <shutdown.h>
-#include <ui_interface.h>
 #include <util/check.h>
 #include <util/system.h>
 #include <util/strencodings.h>
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 73d72b2be639..184a0a888a1a 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -15,7 +15,6 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <script/standard.h>
-#include <ui_interface.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <univalue.h>
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
index e9d1b4cd78c6..65c2967cfa4c 100644
--- a/src/httpserver.cpp
+++ b/src/httpserver.cpp
@@ -6,10 +6,10 @@
 
 #include <chainparamsbase.h>
 #include <netbase.h>
+#include <node/ui_interface.h>
 #include <rpc/protocol.h> // For HTTP status codes
 #include <shutdown.h>
 #include <sync.h>
-#include <ui_interface.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/threadnames.h>
diff --git a/src/index/base.cpp b/src/index/base.cpp
index 4803fd68ea26..cb860f544d4a 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -5,9 +5,9 @@
 #include <chainparams.h>
 #include <index/base.h>
 #include <node/blockstorage.h>
+#include <node/ui_interface.h>
 #include <shutdown.h>
 #include <tinyformat.h>
-#include <ui_interface.h>
 #include <util/thread.h>
 #include <util/translation.h>
 #include <validation.h> // For g_chainman
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
index cf22b279c789..a50b991bb4ce 100644
--- a/src/index/txindex.cpp
+++ b/src/index/txindex.cpp
@@ -4,8 +4,8 @@
 
 #include <index/disktxpos.h>
 #include <index/txindex.h>
+#include <node/ui_interface.h>
 #include <shutdown.h>
-#include <ui_interface.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
diff --git a/src/init.cpp b/src/init.cpp
index 52cb928194db..4f69dea571fd 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -38,6 +38,7 @@
 #include <netbase.h>
 #include <node/blockstorage.h>
 #include <node/context.h>
+#include <node/ui_interface.h>
 #include <policy/feerate.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
@@ -54,7 +55,6 @@
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
-#include <ui_interface.h>
 #include <util/asmap.h>
 #include <util/error.h>
 #include <util/moneystr.h>
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 82b5b23d9e14..4dd73bb62406 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -11,8 +11,8 @@
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
-#include <ui_interface.h>              // For ChangeType
 #include <util/message.h>
+#include <util/ui_change_type.h>
 
 #include <functional>
 #include <map>
diff --git a/src/llmq/chainlocks.cpp b/src/llmq/chainlocks.cpp
index ae1be6f17267..63589eae3b54 100644
--- a/src/llmq/chainlocks.cpp
+++ b/src/llmq/chainlocks.cpp
@@ -14,10 +14,10 @@
 #include <masternode/sync.h>
 #include <net_processing.h>
 #include <node/blockstorage.h>
+#include <node/ui_interface.h>
 #include <scheduler.h>
 #include <spork.h>
 #include <txmempool.h>
-#include <ui_interface.h>
 #include <util/thread.h>
 #include <util/time.h>
 #include <validation.h>
diff --git a/src/masternode/sync.cpp b/src/masternode/sync.cpp
index aa732beb6e7a..afe6d8e150ad 100644
--- a/src/masternode/sync.cpp
+++ b/src/masternode/sync.cpp
@@ -8,8 +8,8 @@
 #include <governance/governance.h>
 #include <netfulfilledman.h>
 #include <netmessagemaker.h>
+#include <node/ui_interface.h>
 #include <shutdown.h>
-#include <ui_interface.h>
 #include <validation.h>
 #include <util/time.h>
 #include <util/translation.h>
diff --git a/src/net.cpp b/src/net.cpp
index 2777d67abc6a..2b74a66d9697 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -20,10 +20,10 @@
 #include <net_permissions.h>
 #include <netaddress.h>
 #include <netbase.h>
+#include <node/ui_interface.h>
 #include <protocol.h>
 #include <random.h>
 #include <scheduler.h>
-#include <ui_interface.h>
 #include <util/sock.h>
 #include <util/strencodings.h>
 #include <util/thread.h>
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 41447b2ed478..9a7dcf910876 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -30,6 +30,7 @@
 #include <node/blockstorage.h>
 #include <node/coin.h>
 #include <node/context.h>
+#include <node/ui_interface.h>
 #include <node/transaction.h>
 #include <policy/feerate.h>
 #include <policy/fees.h>
@@ -44,7 +45,6 @@
 #include <sync.h>
 #include <timedata.h>
 #include <txmempool.h>
-#include <ui_interface.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/system.h>
diff --git a/src/ui_interface.cpp b/src/node/ui_interface.cpp
similarity index 99%
rename from src/ui_interface.cpp
rename to src/node/ui_interface.cpp
index c53bedf2b970..f8698c3f73e3 100644
--- a/src/ui_interface.cpp
+++ b/src/node/ui_interface.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <ui_interface.h>
+#include <node/ui_interface.h>
 
 #include <util/translation.h>
 
diff --git a/src/ui_interface.h b/src/node/ui_interface.h
similarity index 94%
rename from src/ui_interface.h
rename to src/node/ui_interface.h
index 0e6226986942..425a4cf5b045 100644
--- a/src/ui_interface.h
+++ b/src/node/ui_interface.h
@@ -3,8 +3,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_UI_INTERFACE_H
-#define BITCOIN_UI_INTERFACE_H
+#ifndef BITCOIN_NODE_UI_INTERFACE_H
+#define BITCOIN_NODE_UI_INTERFACE_H
 
 #include <functional>
 #include <memory>
@@ -21,14 +21,6 @@ class connection;
 }
 } // namespace boost
 
-/** General change type (added, updated, removed). */
-enum ChangeType
-{
-    CT_NEW,
-    CT_UPDATED,
-    CT_DELETED
-};
-
 /** Signals for UI communication. */
 class CClientUIInterface
 {
@@ -132,8 +124,8 @@ void InitWarning(const bilingual_str& str);
 
 /** Show error message **/
 bool InitError(const bilingual_str& str);
-inline bool AbortError(const bilingual_str& str) { return InitError(str); }
+constexpr auto AbortError = InitError;
 
 extern CClientUIInterface uiInterface;
 
-#endif // BITCOIN_UI_INTERFACE_H
+#endif // BITCOIN_NODE_UI_INTERFACE_H
diff --git a/src/noui.cpp b/src/noui.cpp
index 195a2d8f8f7b..3e715a54a0ae 100644
--- a/src/noui.cpp
+++ b/src/noui.cpp
@@ -7,7 +7,7 @@
 #include <noui.h>
 
 #include <logging.h>
-#include <ui_interface.h>
+#include <node/ui_interface.h>
 #include <util/translation.h>
 
 #include <string>
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index 39ca3b04b5ad..249cb1fb9d71 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -34,7 +34,6 @@
 #include <node/context.h>
 #include <noui.h>
 #include <stacktraces.h>
-#include <ui_interface.h>
 #include <uint256.h>
 #include <util/system.h>
 #include <util/threadnames.h>
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 2d6cad3bf719..067dd052a0f0 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -36,9 +36,9 @@
 #include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
+#include <node/ui_interface.h>
 #include <qt/governancelist.h>
 #include <qt/masternodelist.h>
-#include <ui_interface.h>
 #include <util/system.h>
 #include <util/translation.h>
 
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index e90b9b4f1daf..e484e37603b2 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -22,7 +22,6 @@
 #include <protocol.h>
 #include <script/script.h>
 #include <script/standard.h>
-#include <ui_interface.h>
 #include <util/system.h>
 
 #include <cmath>
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
index 159c3372b0cf..c0b560a52ce9 100644
--- a/src/qt/paymentserver.cpp
+++ b/src/qt/paymentserver.cpp
@@ -16,9 +16,9 @@
 #include <chainparams.h>
 #include <clientversion.h>
 #include <interfaces/node.h>
-#include <policy/policy.h>
 #include <key_io.h>
-#include <ui_interface.h>
+#include <node/ui_interface.h>
+#include <policy/policy.h>
 #include <util/system.h>
 
 #include <cstdlib>
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index c5f14b5506a2..34f9d3d8e251 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -21,9 +21,9 @@
 #include <chainparams.h>
 #include <interfaces/node.h>
 #include <key_io.h>
+#include <node/ui_interface.h>
 #include <policy/fees.h>
 #include <txmempool.h>
-#include <ui_interface.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 #include <wallet/wallet.h>
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
index 088b97ff937b..fab6ef177227 100644
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -18,7 +18,6 @@
 #include <qt/guiutil.h>
 #include <qt/networkstyle.h>
 #include <qt/walletmodel.h>
-#include <ui_interface.h>
 #include <util/system.h>
 #include <util/translation.h>
 
diff --git a/src/qt/transactionview.cpp b/src/qt/transactionview.cpp
index db09d7b09ea2..a73c1da14ac4 100644
--- a/src/qt/transactionview.cpp
+++ b/src/qt/transactionview.cpp
@@ -17,7 +17,7 @@
 #include <qt/walletmodel.h>
 
 #include <interfaces/node.h>
-#include <ui_interface.h>
+#include <node/ui_interface.h>
 
 #include <QCalendarWidget>
 #include <QComboBox>
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index 049fba2f40eb..e0b6bcd3056e 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -21,8 +21,8 @@
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <key_io.h>
+#include <node/ui_interface.h>
 #include <psbt.h>
-#include <ui_interface.h>
 #include <util/system.h> // for GetBoolArg
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index 31b00eed552d..39fec3d7cc74 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -22,8 +22,8 @@
 #include <qt/walletmodel.h>
 
 #include <interfaces/node.h>
+#include <node/ui_interface.h>
 #include <psbt.h>
-#include <ui_interface.h>
 #include <util/strencodings.h>
 
 #include <QAction>
diff --git a/src/shutdown.cpp b/src/shutdown.cpp
index ea6bf9119fd1..8421f4f81bf6 100644
--- a/src/shutdown.cpp
+++ b/src/shutdown.cpp
@@ -6,7 +6,7 @@
 #include <shutdown.h>
 
 #include <logging.h>
-#include <ui_interface.h>
+#include <node/ui_interface.h>
 #include <warnings.h>
 
 #include <config/bitcoin-config.h>
diff --git a/src/timedata.cpp b/src/timedata.cpp
index cdc65b65c720..6ea0b4b9d58a 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -9,8 +9,8 @@
 #include <timedata.h>
 
 #include <netaddress.h>
+#include <node/ui_interface.h>
 #include <sync.h>
-#include <ui_interface.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <warnings.h>
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 646ef850fd2d..fae9ff1128d9 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -5,12 +5,12 @@
 
 #include <txdb.h>
 
+#include <node/ui_interface.h>
 #include <pow.h>
 #include <random.h>
 #include <shutdown.h>
 #include <uint256.h>
 #include <util/system.h>
-#include <ui_interface.h>
 #include <util/translation.h>
 #include <util/vector.h>
 
diff --git a/src/util/ui_change_type.h b/src/util/ui_change_type.h
new file mode 100644
index 000000000000..1db761a18d83
--- /dev/null
+++ b/src/util/ui_change_type.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2012-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_UI_CHANGE_TYPE_H
+#define BITCOIN_UTIL_UI_CHANGE_TYPE_H
+
+/** General change type (added, updated, removed). */
+enum ChangeType {
+    CT_NEW,
+    CT_UPDATED,
+    CT_DELETED
+};
+
+#endif // BITCOIN_UTIL_UI_CHANGE_TYPE_H
diff --git a/src/validation.cpp b/src/validation.cpp
index 8b8cc4ff3003..bc670438b34e 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -24,6 +24,7 @@
 #include <logging/timer.h>
 #include <node/blockstorage.h>
 #include <node/coinstats.h>
+#include <node/ui_interface.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <pow.h>
@@ -39,7 +40,6 @@
 #include <tinyformat.h>
 #include <txdb.h>
 #include <txmempool.h>
-#include <ui_interface.h>
 #include <uint256.h>
 #include <undo.h>
 #include <util/check.h> // For NDEBUG compile time check
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index aa783cfd3fff..4b432de993c8 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -9,8 +9,8 @@
 #include <interfaces/wallet.h>
 #include <net.h>
 #include <node/context.h>
+#include <node/ui_interface.h>
 #include <univalue.h>
-#include <ui_interface.h>
 #include <util/check.h>
 #include <util/error.h>
 #include <util/system.h>
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index e6acbd0c1000..4eb357460824 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -15,10 +15,10 @@
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
-#include <ui_interface.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/system.h>
+#include <util/ui_change_type.h>
 #include <validation.h>
 #include <wallet/context.h>
 #include <wallet/fees.h>
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 775ea04ec622..ee5caa82fa3c 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -16,11 +16,11 @@
 #include <psbt.h>
 #include <saltedhasher.h>
 #include <tinyformat.h>
-#include <ui_interface.h>
 #include <util/message.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/strencodings.h>
+#include <util/ui_change_type.h>
 #include <validationinterface.h>
 #include <wallet/coincontrol.h>
 #include <wallet/crypter.h>