{

if (m_is_masternode) return false; // no client-side mixing on masternodes

if (nState != POOL_STATE_IDLE) return false;

return false;

}

} else {

WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::DoAutomaticDenominating -- invalid collateral, recreating...\n");

if (!CreateCollateralTransaction(txMyCollateral, strReason)) {

WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::DoAutomaticDenominating -- create collateral error: %s\n", strReason);

return false;

}

{

if (m_is_masternode) return false; // no client-side mixing on masternodes

if (!CCoinJoinClientOptions::IsEnabled() || !IsMixing()) return false;

return false;

}

}

return fResult;

CheckQueue();

}

{

if (!CCoinJoinClientOptions::IsEnabled()) return;

if (m_is_masternode) return; // no client-side mixing on masternodes

CheckTimeout();

ProcessPendingDsaRequest(connman);

if (nDoAutoNextRun == nTick) {

nDoAutoNextRun = nTick + COINJOIN_AUTO_TIMEOUT_MIN + GetRandInt(COINJOIN_AUTO_TIMEOUT_MAX - COINJOIN_AUTO_TIMEOUT_MIN);

}

}

{

LOCK(cs_wallet_manager_map);

for (auto& [_, clientman] : m_wallet_manager_map) {

}

}

class CConnman;

class CDeterministicMN;

class CDeterministicMNManager;

class CMasternodeMetaMan;

class CMasternodeSync;

class CoinJoinWalletManager;

class CTxMemPool;

using wallet_name_cjman_map = std::map<const std::string, std::unique_ptr<CCoinJoinClientManager>>;

const CMasternodeSync& mn_sync, const std::unique_ptr<CCoinJoinClientQueueManager>& queueman, bool is_masternode)

m_queueman(queueman), m_is_masternode{is_masternode}

{}

};

CConnman& m_connman;

CDeterministicMNManager& m_dmnman;

CMasternodeMetaMan& m_mn_metaman;

const CMasternodeSync& m_mn_sync;

const std::unique_ptr<CCoinJoinClientQueueManager>& m_queueman;

bool GetMixingMasternodeInfo(CDeterministicMNCPtr& ret) const;

/// Passively run mixing in the background according to the configuration in settings

/// As a client, submit part of a future mixing transaction to a Masternode to start the process

bool SubmitDenominate(CConnman& connman);

bool GetMixingMasternodesInfo(std::vector<CDeterministicMNCPtr>& vecDmnsRet) const EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);

/// Passively run mixing in the background according to the configuration in settings

bool TrySubmitDenominate(const CService& mnAddr, CConnman& connman) EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);

bool MarkAlreadyJoinedQueueAsTried(CCoinJoinQueue& dsq) const EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);

void UpdatedBlockTip(const CBlockIndex* pindex);

void GetJsonInfo(UniValue& obj) const EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);

};

AssertLockHeld(cs_main);

if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {

/* Fetch fee and fast-fail if ATMP fails regardless */

return false;

/* Don't re-run ATMP if only doing test run */

return true;

}

}

{

if (txCollateral.vout.empty()) return false;

if (txCollateral.nLockTime != 0) return false;

return false;

}

nValueIn += mempoolTx->vout[txin.prevout.n].nValue;

nValueIn += coin.out.nValue;

} else {

LogPrint(BCLog::COINJOIN, "CoinJoin::IsCollateralValid -- Unknown inputs in collateral transaction, txCollateral=%s", txCollateral.ToString()); /* Continued */

{

LOCK(cs_main);

return false;

}

}

class CConnman;

class CBLSPublicKey;

class CBlockIndex;

class CMasternodeSync;

class CTxMemPool;

class TxValidationState;

constexpr CAmount GetMaxPoolAmount() { return COINJOIN_ENTRY_MAX_SIZE * vecStandardDenominations.front(); }

/// If the collateral is valid given by a client

}

};

#endif // BITCOIN_COINJOIN_COINJOIN_H

#endif // ENABLE_WALLET

#include <coinjoin/server.h>

CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,

const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,

std::unique_ptr<PeerManager>& peerman, bool relay_txes) :

dstxman{std::make_unique<CDSTXManager>()},

#ifdef ENABLE_WALLET

queueman, /* is_masternode = */ mn_activeman != nullptr)},

queueman{relay_txes

? std::make_unique<CCoinJoinClientQueueManager>(connman, peerman, *walletman, dmnman, mn_metaman,

mn_sync, /* is_masternode = */ mn_activeman != nullptr)

: nullptr},

#endif // ENABLE_WALLET

mn_sync, peerman)}

{}

class CActiveMasternodeManager;

class CBlockPolicyEstimator;

class CCoinJoinServer;

class CConnman;

class CDeterministicMNManager;

class CDSTXManager;

class CMasternodeMetaMan;

class CMasternodeSync;

class CTxMemPool;

struct CJContext {

CJContext() = delete;

CJContext(const CJContext&) = delete;

CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman,

const CMasternodeSync& mn_sync, std::unique_ptr<PeerManager>& peerman, bool relay_txes);

~CJContext();

// See if the transaction is valid

TRY_LOCK(cs_main, lockMain);

mempool.PrioritiseTransaction(hashTx, 0.1 * COIN);

WITH_LOCK(cs_coinjoin, SetNull());

// not much we can do in this case, just notify clients

RelayCompletedTransaction(ERR_INVALID_TX);

void CCoinJoinServer::ConsumeCollateral(const CTransactionRef& txref) const

{

LOCK(cs_main);

} else {

Assert(m_peerman)->RelayTransaction(txref->GetHash());

LogPrint(BCLog::COINJOIN, "%s -- Collateral was consumed\n", __func__);

return false;

}

LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR: collateral not valid!\n", __func__);

nMessageIDRet = ERR_INVALID_COLLATERAL;

return false;

}

bool fConsumeCollateral{false};

LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR! IsValidInOuts() failed: %s\n", __func__, CoinJoin::GetMessageByID(nMessageIDRet).translated);

if (fConsumeCollateral) {

ConsumeCollateral(entry.txCollateral);

}

// check collateral

LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- collateral not valid!\n", __func__);

nMessageIDRet = ERR_INVALID_COLLATERAL;

return false;

#include <protocol.h>

class CActiveMasternodeManager;

class CCoinJoinServer;

class CDataStream;

class CDeterministicMNManager;

class CDSTXManager;

class CMasternodeMetaMan;

class CNode;

class CTxMemPool;

class CCoinJoinServer : public CCoinJoinBaseSession, public CCoinJoinBaseManager

{

CConnman& connman;

CDeterministicMNManager& m_dmnman;

CDSTXManager& m_dstxman;

void SetNull() override EXCLUSIVE_LOCKS_REQUIRED(cs_coinjoin);

CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,

const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,

std::unique_ptr<PeerManager>& peerman) :

connman(_connman),

m_dmnman(dmnman),

m_dstxman(dstxman),

node.llmq_ctx->Stop();

}

node.llmq_ctx.reset();

*node.mempool, node.mn_activeman.get(), *node.mn_sync, node.peerman, /* unit_tests = */ false, /* wipe = */ fReset || fReindexChainState);

// Enable CMNHFManager::{Process, Undo}Block

node.mnhf_manager->ConnectManagers(node.chainman.get(), node.llmq_ctx->qman.get());

// ********************************************************* Step 7c: Setup CoinJoin

node.mn_activeman.get(), *node.mn_sync, node.peerman, !ignores_incoming_txs);

#ifdef ENABLE_WALLET