diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp index 8026e2e88765..df5ea641ad2f 100644 --- a/src/chainlock/chainlock.cpp +++ b/src/chainlock/chainlock.cpp @@ -64,17 +64,18 @@ CChainLocksHandler::~CChainLocksHandler() void CChainLocksHandler::Start(const llmq::CInstantSendManager& isman) { - if (m_signer) { - m_signer->Start(); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->Start(); } scheduler->scheduleEvery( [&]() { + auto signer = m_signer.load(std::memory_order_acquire); CheckActiveState(); EnforceBestChainLock(); Cleanup(); // regularly retry signing the current chaintip as it might have failed before due to missing islocks - if (m_signer) { - m_signer->TrySignChainTip(isman); + if (signer) { + signer->TrySignChainTip(isman); } }, std::chrono::seconds{5}); @@ -83,8 +84,8 @@ void CChainLocksHandler::Start(const llmq::CInstantSendManager& isman) void CChainLocksHandler::Stop() { scheduler->stop(); - if (m_signer) { - m_signer->Stop(); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->Stop(); } } @@ -218,11 +219,12 @@ void CChainLocksHandler::UpdatedBlockTip(const llmq::CInstantSendManager& isman) if (bool expected = false; tryLockChainTipScheduled.compare_exchange_strong(expected, true)) { scheduler->scheduleFromNow( [&]() { + auto signer = m_signer.load(std::memory_order_acquire); CheckActiveState(); EnforceBestChainLock(); Cleanup(); - if (m_signer) { - m_signer->TrySignChainTip(isman); + if (signer) { + signer->TrySignChainTip(isman); } tryLockChainTipScheduled = false; }, @@ -274,16 +276,16 @@ void CChainLocksHandler::BlockConnected(const std::shared_ptr& pbl } // We need this information later when we try to sign a new tip, so that we can determine if all included TXs are safe. - if (m_signer) { - m_signer->UpdateBlockHashTxidMap(pindex->GetBlockHash(), pblock->vtx); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->UpdateBlockHashTxidMap(pindex->GetBlockHash(), pblock->vtx); } } void CChainLocksHandler::BlockDisconnected(const std::shared_ptr& pblock, gsl::not_null pindexDisconnected) { - if (m_signer) { - m_signer->EraseFromBlockHashTxidMap(pindexDisconnected->GetBlockHash()); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->EraseFromBlockHashTxidMap(pindexDisconnected->GetBlockHash()); } } @@ -451,8 +453,8 @@ void CChainLocksHandler::Cleanup() } } - if (m_signer) { - const auto cleanup_txes{m_signer->Cleanup()}; + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + const auto cleanup_txes{signer->Cleanup()}; LOCK(cs); for (const auto& tx : cleanup_txes) { for (const auto& txid : *tx) { diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h index 297f0ef3168b..2c78dcb08871 100644 --- a/src/chainlock/chainlock.h +++ b/src/chainlock/chainlock.h @@ -46,7 +46,7 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent std::unique_ptr scheduler; std::unique_ptr scheduler_thread; - chainlock::ChainLockSigner* m_signer{nullptr}; + std::atomic m_signer{nullptr}; mutable Mutex cs; std::atomic tryLockChainTipScheduled{false}; @@ -73,10 +73,10 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent void ConnectSigner(gsl::not_null signer) { // Prohibit double initialization - assert(m_signer == nullptr); - m_signer = signer; + assert(m_signer.load(std::memory_order_acquire) == nullptr); + m_signer.store(signer, std::memory_order_release); } - void DisconnectSigner() { m_signer = nullptr; } + void DisconnectSigner() { m_signer.store(nullptr, std::memory_order_release); } void Start(const llmq::CInstantSendManager& isman); void Stop(); diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp index c1c1e76df740..fb56488c28dc 100644 --- a/src/evo/mnhftx.cpp +++ b/src/evo/mnhftx.cpp @@ -201,11 +201,12 @@ static bool extractSignals(const ChainstateManager& chainman, const llmq::CQuoru std::optional CMNHFManager::ProcessBlock(const CBlock& block, const CBlockIndex* const pindex, bool fJustCheck, BlockValidationState& state) { - assert(m_chainman && m_qman); + auto chainman = Assert(m_chainman.load(std::memory_order_acquire)); + auto qman = Assert(m_qman.load(std::memory_order_acquire)); try { std::vector new_signals; - if (!extractSignals(*m_chainman, *m_qman, block, pindex, new_signals, state)) { + if (!extractSignals(*chainman, *qman, block, pindex, new_signals, state)) { // state is set inside extractSignals return std::nullopt; } @@ -252,11 +253,12 @@ std::optional CMNHFManager::ProcessBlock(const CBlock& bl bool CMNHFManager::UndoBlock(const CBlock& block, const CBlockIndex* const pindex) { - assert(m_chainman && m_qman); + auto chainman = Assert(m_chainman.load(std::memory_order_acquire)); + auto qman = Assert(m_qman.load(std::memory_order_acquire)); std::vector excluded_signals; BlockValidationState state; - if (!extractSignals(*m_chainman, *m_qman, block, pindex, excluded_signals, state)) { + if (!extractSignals(*chainman, *qman, block, pindex, excluded_signals, state)) { LogPrintf("CMNHFManager::%s: failed to extract signals\n", __func__); return false; } @@ -372,19 +374,28 @@ void CMNHFManager::AddSignal(const CBlockIndex* const pindex, int bit) void CMNHFManager::ConnectManagers(gsl::not_null chainman, gsl::not_null qman) { // Do not allow double-initialization - assert(m_chainman == nullptr && m_qman == nullptr); - m_chainman = chainman; - m_qman = qman; + assert(m_chainman.load(std::memory_order_acquire) == nullptr); + m_chainman.store(chainman, std::memory_order_release); + assert(m_qman.load(std::memory_order_acquire) == nullptr); + m_qman.store(qman, std::memory_order_release); +} + +void CMNHFManager::DisconnectManagers() +{ + m_chainman.store(nullptr, std::memory_order_release); + m_qman.store(nullptr, std::memory_order_release); } bool CMNHFManager::ForceSignalDBUpdate() { + auto chainman = Assert(m_chainman.load(std::memory_order_acquire)); + // force ehf signals db update auto dbTx = m_evoDb.BeginTransaction(); const bool last_legacy = bls::bls_legacy_scheme.load(); bls::bls_legacy_scheme.store(false); - GetSignalsStage(m_chainman->ActiveChainstate().m_chain.Tip()); + GetSignalsStage(chainman->ActiveChainstate().m_chain.Tip()); bls::bls_legacy_scheme.store(last_legacy); dbTx->Commit(); diff --git a/src/evo/mnhftx.h b/src/evo/mnhftx.h index 2dc38919cf48..ee75c867c09c 100644 --- a/src/evo/mnhftx.h +++ b/src/evo/mnhftx.h @@ -5,16 +5,19 @@ #ifndef BITCOIN_EVO_MNHFTX_H #define BITCOIN_EVO_MNHFTX_H -#include -#include +#include #include #include +#include + +#include +#include + +#include #include +#include #include -#include -#include -#include class BlockValidationState; class CBlock; @@ -91,8 +94,8 @@ class CMNHFManager : public AbstractEHFManager { private: CEvoDB& m_evoDb; - ChainstateManager* m_chainman{nullptr}; - llmq::CQuorumManager* m_qman{nullptr}; + std::atomic m_chainman{nullptr}; + std::atomic m_qman{nullptr}; static constexpr size_t MNHFCacheSize = 1000; Mutex cs_cache; @@ -144,7 +147,7 @@ class CMNHFManager : public AbstractEHFManager * * @pre Must be called before LLMQContext (containing llmq::CQuorumManager) is destroyed. */ - void DisconnectManagers() { m_chainman = nullptr; m_qman = nullptr; }; + void DisconnectManagers(); bool ForceSignalDBUpdate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main); diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp index 37232fcde543..5295a0a54870 100644 --- a/src/instantsend/instantsend.cpp +++ b/src/instantsend/instantsend.cpp @@ -75,15 +75,15 @@ void CInstantSendManager::Start(PeerManager& peerman) workThread = std::thread(&util::TraceThread, "isman", [this, &peerman] { WorkThreadMain(peerman); }); - if (m_signer) { - m_signer->Start(); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->Start(); } } void CInstantSendManager::Stop() { - if (m_signer) { - m_signer->Stop(); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->Stop(); } // make sure to call InterruptWorkerThread() first @@ -348,8 +348,8 @@ MessageProcessingResult CInstantSendManager::ProcessInstantSendLock(NodeId from, LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: processing islock, peer=%d\n", __func__, islock->txid.ToString(), hash.ToString(), from); - if (m_signer) { - m_signer->ClearLockFromQueue(islock); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->ClearLockFromQueue(islock); } if (db.KnownInstantSendLock(hash)) { return {}; @@ -449,8 +449,8 @@ void CInstantSendManager::TransactionAddedToMempool(const CTransactionRef& tx) } if (islock == nullptr) { - if (m_signer) { - m_signer->ProcessTx(*tx, false, Params().GetConsensus()); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->ProcessTx(*tx, false, Params().GetConsensus()); } // TX is not locked, so make sure it is tracked AddNonLockedTx(tx, nullptr); @@ -491,8 +491,8 @@ void CInstantSendManager::BlockConnected(const std::shared_ptr& pb } if (!IsLocked(tx->GetHash()) && !has_chainlock) { - if (m_signer) { - m_signer->ProcessTx(*tx, true, Params().GetConsensus()); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->ProcessTx(*tx, true, Params().GetConsensus()); } // TX is not locked, so make sure it is tracked AddNonLockedTx(tx, pindex); @@ -597,16 +597,16 @@ void CInstantSendManager::RemoveNonLockedTx(const uint256& txid, bool retryChild void CInstantSendManager::RemoveConflictedTx(const CTransaction& tx) { RemoveNonLockedTx(tx.GetHash(), false); - if (m_signer) { - m_signer->ClearInputsFromQueue(GetIdsFromLockable(tx.vin)); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->ClearInputsFromQueue(GetIdsFromLockable(tx.vin)); } } void CInstantSendManager::TruncateRecoveredSigsForInputs(const instantsend::InstantSendLock& islock) { auto ids = GetIdsFromLockable(islock.inputs); - if (m_signer) { - m_signer->ClearInputsFromQueue(ids); + if (auto signer = m_signer.load(std::memory_order_acquire); signer) { + signer->ClearInputsFromQueue(ids); } for (const auto& id : ids) { sigman.TruncateRecoveredSig(Params().GetConsensus().llmqTypeDIP0024InstantSend, id); @@ -925,7 +925,8 @@ void CInstantSendManager::WorkThreadMain(PeerManager& peerman) for (auto& [node_id, mpr] : peer_activity) { peerman.PostProcessMessage(std::move(mpr), node_id); } - if (!m_signer) return more_work; + auto signer = m_signer.load(std::memory_order_acquire); + if (!signer) return more_work; // Construct set of non-locked transactions that are pending to retry std::vector txns{}; { @@ -942,7 +943,7 @@ void CInstantSendManager::WorkThreadMain(PeerManager& peerman) } } // Retry processing them - m_signer->ProcessPendingRetryLockTxs(txns); + signer->ProcessPendingRetryLockTxs(txns); return more_work; }(); diff --git a/src/instantsend/instantsend.h b/src/instantsend/instantsend.h index 065a3fd8661c..b7040bf45b66 100644 --- a/src/instantsend/instantsend.h +++ b/src/instantsend/instantsend.h @@ -59,7 +59,7 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent CTxMemPool& mempool; const CMasternodeSync& m_mn_sync; - instantsend::InstantSendSigner* m_signer{nullptr}; + std::atomic m_signer{nullptr}; std::thread workThread; CThreadInterrupt workInterrupt; @@ -97,10 +97,10 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent void ConnectSigner(gsl::not_null signer) { // Prohibit double initialization - assert(m_signer == nullptr); - m_signer = signer; + assert(m_signer.load(std::memory_order_acquire) == nullptr); + m_signer.store(signer, std::memory_order_release); } - void DisconnectSigner() { m_signer = nullptr; } + void DisconnectSigner() { m_signer.store(nullptr, std::memory_order_release); } void Start(PeerManager& peerman); void Stop(); diff --git a/src/net_processing.cpp b/src/net_processing.cpp index 4af010dadb5a..8f64d634a3b5 100644 --- a/src/net_processing.cpp +++ b/src/net_processing.cpp @@ -2276,11 +2276,11 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv) case MSG_ISDLOCK: return m_llmq_ctx->isman->AlreadyHave(inv); case MSG_DSQ: + return #ifdef ENABLE_WALLET - return m_cj_ctx->queueman->HasQueue(inv.hash) || (m_active_ctx && m_active_ctx->cj_server->HasQueue(inv.hash)); -#else - return m_active_ctx && m_active_ctx->cj_server->HasQueue(inv.hash); -#endif + (m_cj_ctx->queueman && m_cj_ctx->queueman->HasQueue(inv.hash)) || +#endif // ENABLE_WALLET + (m_active_ctx && m_active_ctx->cj_server->HasQueue(inv.hash)); } @@ -2885,7 +2885,7 @@ void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic if (!push && inv.type == MSG_DSQ) { auto opt_dsq = m_active_ctx ? m_active_ctx->cj_server->GetQueueFromHash(inv.hash) : std::nullopt; #ifdef ENABLE_WALLET - if (!opt_dsq.has_value()) { + if (m_cj_ctx->queueman && !opt_dsq.has_value()) { opt_dsq = m_cj_ctx->queueman->GetQueueFromHash(inv.hash); } #endif @@ -5273,7 +5273,9 @@ void PeerManagerImpl::ProcessMessage( { //probably one the extensions #ifdef ENABLE_WALLET - PostProcessMessage(m_cj_ctx->queueman->ProcessMessage(pfrom.GetId(), m_connman, *this, msg_type, vRecv), pfrom.GetId()); + if (m_cj_ctx->queueman) { + PostProcessMessage(m_cj_ctx->queueman->ProcessMessage(pfrom.GetId(), m_connman, *this, msg_type, vRecv), pfrom.GetId()); + } m_cj_ctx->walletman->ForEachCJClientMan([this, &pfrom, &msg_type, &vRecv](std::unique_ptr& clientman) { clientman->ProcessMessage(pfrom, m_chainman.ActiveChainstate(), m_connman, m_mempool, msg_type, vRecv); }); diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp index c7d29f65204c..a0f03757813d 100644 --- a/src/rpc/coinjoin.cpp +++ b/src/rpc/coinjoin.cpp @@ -474,7 +474,9 @@ static RPCHelpMan getcoinjoininfo() #ifdef ENABLE_WALLET CCoinJoinClientOptions::GetJsonInfo(obj); - obj.pushKV("queue_size", node.cj_ctx->queueman->GetQueueSize()); + if (node.cj_ctx->queueman) { + obj.pushKV("queue_size", node.cj_ctx->queueman->GetQueueSize()); + } const std::shared_ptr wallet = GetWalletForJSONRPCRequest(request); if (!wallet) { diff --git a/src/txmempool.cpp b/src/txmempool.cpp index 32f91fc65c06..2c019e72903f 100644 --- a/src/txmempool.cpp +++ b/src/txmempool.cpp @@ -440,10 +440,16 @@ CTxMemPool::CTxMemPool(CBlockPolicyEstimator* estimator, int check_ratio) void CTxMemPool::ConnectManagers(gsl::not_null dmnman, gsl::not_null isman) { // Do not allow double-initialization - assert(m_dmnman == nullptr); - m_dmnman = dmnman; - assert(m_isman == nullptr); - m_isman = isman; + assert(m_dmnman.load(std::memory_order_acquire) == nullptr); + m_dmnman.store(dmnman, std::memory_order_release); + assert(m_isman.load(std::memory_order_acquire) == nullptr); + m_isman.store(isman, std::memory_order_release); +} + +void CTxMemPool::DisconnectManagers() +{ + m_dmnman.store(nullptr, std::memory_order_release); + m_isman.store(nullptr, std::memory_order_release); } bool CTxMemPool::isSpent(const COutPoint& outpoint) const @@ -516,8 +522,8 @@ void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAnces // Invalid ProTxes should never get this far because transactions should be // fully checked by AcceptToMemoryPool() at this point, so we just assume that // everything is fine here. - if (m_dmnman) { - addUncheckedProTx(newit, tx); + if (auto dmnman = m_dmnman.load(std::memory_order_acquire); dmnman) { + addUncheckedProTx(*dmnman, newit, tx); } } @@ -641,10 +647,9 @@ void CTxMemPool::removeSpentIndex(const uint256 txhash) } } -void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, const CTransaction& tx) +void CTxMemPool::addUncheckedProTx(CDeterministicMNManager& dmnman, indexed_transaction_set::iterator& newit, + const CTransaction& tx) { - assert(m_dmnman); - const uint256 tx_hash{tx.GetHash()}; if (tx.nType == TRANSACTION_PROVIDER_REGISTER) { auto proTx = *Assert(GetTxPayload(tx)); @@ -671,7 +676,7 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con auto proTx = *Assert(GetTxPayload(tx)); mapProTxRefs.emplace(proTx.proTxHash, tx_hash); mapProTxBlsPubKeyHashes.emplace(proTx.pubKeyOperator.GetHash(), tx_hash); - auto dmn = Assert(m_dmnman->GetListAtChainTip().GetMN(proTx.proTxHash)); + auto dmn = Assert(dmnman.GetListAtChainTip().GetMN(proTx.proTxHash)); newit->validForProTxKey = ::SerializeHash(dmn->pdmnState->pubKeyOperator); if (dmn->pdmnState->pubKeyOperator != proTx.pubKeyOperator) { newit->isKeyChangeProTx = true; @@ -679,7 +684,7 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_REVOKE) { auto proTx = *Assert(GetTxPayload(tx)); mapProTxRefs.emplace(proTx.proTxHash, tx_hash); - auto dmn = Assert(m_dmnman->GetListAtChainTip().GetMN(proTx.proTxHash)); + auto dmn = Assert(dmnman.GetListAtChainTip().GetMN(proTx.proTxHash)); newit->validForProTxKey = ::SerializeHash(dmn->pdmnState->pubKeyOperator); if (dmn->pdmnState->pubKeyOperator.Get() != CBLSPublicKey()) { newit->isKeyChangeProTx = true; @@ -721,7 +726,7 @@ void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason) } else vTxHashes.clear(); - if (m_dmnman) { + if (m_dmnman.load(std::memory_order_acquire)) { removeUncheckedProTx(it->GetTx()); } @@ -926,7 +931,7 @@ void CTxMemPool::removeProTxCollateralConflicts(const CTransaction &tx, const CO void CTxMemPool::removeProTxSpentCollateralConflicts(const CTransaction &tx) { - assert(m_dmnman); + auto dmnman = Assert(m_dmnman.load(std::memory_order_acquire)); // Remove TXs that refer to a MN for which the collateral was spent auto removeSpentCollateralConflict = [&](const uint256& proTxHash) EXCLUSIVE_LOCKS_REQUIRED(cs) { @@ -948,7 +953,7 @@ void CTxMemPool::removeProTxSpentCollateralConflicts(const CTransaction &tx) } } }; - auto mnList = m_dmnman->GetListAtChainTip(); + auto mnList = dmnman->GetListAtChainTip(); for (const auto& in : tx.vin) { auto collateralIt = mapProTxCollaterals.find(in.prevout); if (collateralIt != mapProTxCollaterals.end()) { @@ -1070,7 +1075,7 @@ void CTxMemPool::removeForBlock(const std::vector& vtx, unsigne RemoveStaged(stage, true, MemPoolRemovalReason::BLOCK); } removeConflicts(*tx); - if (m_dmnman) { + if (m_dmnman.load(std::memory_order_acquire)) { removeProTxConflicts(*tx); } ClearPrioritisation(tx->GetHash()); @@ -1328,7 +1333,7 @@ TxMempoolInfo CTxMemPool::info(const uint256& hash) const } bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const { - assert(m_dmnman); + auto dmnman = Assert(m_dmnman.load(std::memory_order_acquire)); LOCK(cs); @@ -1394,7 +1399,7 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const { auto& proTx = *opt_proTx; // this method should only be called with validated ProTxs - auto dmn = m_dmnman->GetListAtChainTip().GetMN(proTx.proTxHash); + auto dmn = dmnman->GetListAtChainTip().GetMN(proTx.proTxHash); if (!dmn) { LogPrint(BCLog::MEMPOOL, "%s: ERROR: Masternode is not in the list, proTxHash: %s\n", __func__, proTx.proTxHash.ToString()); return true; // i.e. failed to find validated ProTx == conflict @@ -1416,7 +1421,7 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const { } auto& proTx = *opt_proTx; // this method should only be called with validated ProTxs - auto dmn = m_dmnman->GetListAtChainTip().GetMN(proTx.proTxHash); + auto dmn = dmnman->GetListAtChainTip().GetMN(proTx.proTxHash); if (!dmn) { LogPrint(BCLog::MEMPOOL, "%s: ERROR: Masternode is not in the list, proTxHash: %s\n", __func__, proTx.proTxHash.ToString()); return true; // i.e. failed to find validated ProTx == conflict @@ -1566,12 +1571,12 @@ void CTxMemPool::RemoveStaged(setEntries &stage, bool updateDescendants, MemPool int CTxMemPool::Expire(std::chrono::seconds time) { AssertLockHeld(cs); - assert(m_isman); + auto isman = Assert(m_isman.load(std::memory_order_acquire)); indexed_transaction_set::index::type::iterator it = mapTx.get().begin(); setEntries toremove; while (it != mapTx.get().end() && it->GetTime() < time) { // locked txes do not expire until mined and have sufficient confirmations - if (m_isman->IsLocked(it->GetTx().GetHash())) { + if (isman->IsLocked(it->GetTx().GetHash())) { it++; continue; } diff --git a/src/txmempool.h b/src/txmempool.h index 25eedd282b9a..e28b6c856ff6 100644 --- a/src/txmempool.h +++ b/src/txmempool.h @@ -435,8 +435,8 @@ class CTxMemPool const int m_check_ratio; //!< Value n means that 1 times in n we check. std::atomic nTransactionsUpdated{0}; //!< Used by getblocktemplate to trigger CreateNewBlock() invocation CBlockPolicyEstimator* const minerPolicyEstimator; - CDeterministicMNManager* m_dmnman{nullptr}; - llmq::CInstantSendManager* m_isman{nullptr}; + std::atomic m_dmnman{nullptr}; + std::atomic m_isman{nullptr}; uint64_t totalTxSize GUARDED_BY(cs); //!< sum of all mempool tx' byte sizes CAmount m_total_fee GUARDED_BY(cs); //!< sum of all mempool tx's fees (NOT modified fee) @@ -590,7 +590,7 @@ class CTxMemPool * * @pre Must be called before CDeterministicMNManager and CInstantSendManager are destroyed. */ - void DisconnectManagers() { m_dmnman = nullptr; m_isman = nullptr; } + void DisconnectManagers(); /** * If sanity-checking is turned on, check makes sure the pool is @@ -886,9 +886,9 @@ class CTxMemPool /** * addUnchecked extension for Dash-specific transactions (ProTx). - * Depends on CDeterministicMNManager. */ - void addUncheckedProTx(indexed_transaction_set::iterator& newit, const CTransaction& tx); + void addUncheckedProTx(CDeterministicMNManager& dmnman, indexed_transaction_set::iterator& newit, + const CTransaction& tx); /** Before calling removeUnchecked for a given transaction, * UpdateForRemoveFromMempool must be called on the entire (dependent) set diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py index ca7f05224643..b56ef5ddc419 100755 --- a/test/functional/test_framework/p2p.py +++ b/test/functional/test_framework/p2p.py @@ -130,9 +130,7 @@ b"getcfilters": msg_getcfilters, b"getdata": msg_getdata, b"getheaders": msg_getheaders, - b"getheaders2": msg_getheaders2, b"headers": msg_headers, - b"headers2": msg_headers2, b"inv": msg_inv, b"mempool": msg_mempool, b"merkleblock": msg_merkleblock, @@ -141,26 +139,52 @@ b"sendaddrv2": msg_sendaddrv2, b"sendcmpct": msg_sendcmpct, b"sendheaders": msg_sendheaders, - b"sendheaders2": msg_sendheaders2, b"sendtxrcncl": msg_sendtxrcncl, b"tx": msg_tx, b"verack": msg_verack, b"version": msg_version, # Dash Specific b"clsig": msg_clsig, + b"dsa": None, + b"dsc": None, + b"dsf": None, + b"dsi": None, + b"dsq": None, + b"dss": None, + b"dssu": None, + b"dstx": None, + b"getheaders2": msg_getheaders2, b"getmnlistd": msg_getmnlistd, + b"getqrinfo": None, b"getsporks": None, + b"govobj": None, + b"govobjvote": None, b"govsync": None, + b"headers2": msg_headers2, b"isdlock": msg_isdlock, + b"mnauth": None, b"mnlistdiff": msg_mnlistdiff, b"notfound": msg_notfound, + b"qbsigs": None, + b"qcomplaint": None, + b"qcontrib": None, + b"qdata": msg_qdata, b"qfcommit": None, - b"qsendrecsigs": None, b"qgetdata": msg_qgetdata, - b"qdata": msg_qdata, - b"qwatch" : None, + b"qgetsigs": None, + b"qjustify": None, + b"qpcommit": None, + b"qrinfo": None, + b"qsendrecsigs": None, + b"qsigrec": None, + b"qsigsesann": None, + b"qsigshare": None, + b"qsigsinv": None, + b"qwatch": None, b"senddsq": None, + b"sendheaders2": msg_sendheaders2, b"spork": None, + b"ssc": None, }