refactor: rename llmq::CChainLocksHandler to chainlock::ChainlockHandler

knst · knst · commit 38bfafafaaa3 · 2026-01-22T15:55:29.000+07:00
diff --git a/src/active/context.cpp b/src/active/context.cpp
@@ -26,7 +26,7 @@
 ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
                              CDeterministicMNManager& dmnman, CGovernanceManager& govman,
                              CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                             CTxMemPool& mempool, llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman,
+                             CTxMemPool& mempool, chainlock::ChainlockHandler& clhandler, llmq::CInstantSendManager& isman,
                              llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
                              llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman,
                              PeerManager& peerman, const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
diff --git a/src/active/context.h b/src/active/context.h
@@ -30,13 +30,13 @@ class GovernanceSigner;
 class PeerManager;
 namespace chainlock {
 class Chainlocks;
+class ChainlockHandler;
 class ChainLockSigner;
 } // namespace chainlock
 namespace instantsend {
 class InstantSendSigner;
 } // namespace instantsend
 namespace llmq {
-class CChainLocksHandler;
 class CDKGDebugManager;
 class CDKGSessionManager;
 class CEHFSignalsHandler;
@@ -64,7 +64,7 @@ struct ActiveContext final : public CValidationInterface {
     explicit ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
                            CDeterministicMNManager& dmnman, CGovernanceManager& govman, CMasternodeMetaMan& mn_metaman,
                            CMNHFManager& mnhfman, CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks, CTxMemPool& mempool,
-                           llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman,
+                           chainlock::ChainlockHandler& clhandler, llmq::CInstantSendManager& isman,
                            llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
                            llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman, PeerManager& peerman,
                            const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
@@ -107,7 +107,7 @@ bool Chainlocks::UpdateBestChainlock(const uint256& hash, const chainlock::Chain
     if (pindex) {
         if (pindex->nHeight != clsig.getHeight()) {
             // Should not happen, same as the conflict check from above.
-            LogPrintf("CChainLocksHandler::%s -- height of CLSIG (%s) does not match the specified block's height (%d)\n",
+            LogPrintf("Chainlocks::%s -- height of CLSIG (%s) does not match the specified block's height (%d)\n",
                       __func__, clsig.ToString(), pindex->nHeight);
             // Note: not relaying clsig here
             return false;
diff --git a/src/chainlock/handler.cpp b/src/chainlock/handler.cpp
@@ -29,14 +29,14 @@ CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMe
 
 using node::GetTransaction;
 
-namespace llmq {
 namespace {
 static constexpr auto CLEANUP_SEEN_TIMEOUT{24h};
 //! How long to wait for islocks until we consider a block with non-islocked TXs to be safe to sign
 static constexpr auto WAIT_FOR_ISLOCK_TIMEOUT{10min};
 } // anonymous namespace
 
-CChainLocksHandler::CChainLocksHandler(chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,
+namespace chainlock {
+ChainlockHandler::ChainlockHandler(chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,
                                        CTxMemPool& _mempool, const CMasternodeSync& mn_sync) :
     m_chainlocks{chainlocks},
     m_chainman{chainman},
@@ -48,13 +48,13 @@ CChainLocksHandler::CChainLocksHandler(chainlock::Chainlocks& chainlocks, Chains
 {
 }
 
-CChainLocksHandler::~CChainLocksHandler()
+ChainlockHandler::~ChainlockHandler()
 {
     scheduler->stop();
     scheduler_thread->join();
 }
 
-void CChainLocksHandler::Start()
+void ChainlockHandler::Start()
 {
     scheduler->scheduleEvery(
         [&]() {
@@ -65,18 +65,18 @@ void CChainLocksHandler::Start()
         std::chrono::seconds{5});
 }
 
-void CChainLocksHandler::Stop()
+void ChainlockHandler::Stop()
 {
     scheduler->stop();
 }
 
-bool CChainLocksHandler::AlreadyHave(const CInv& inv) const
+bool ChainlockHandler::AlreadyHave(const CInv& inv) const
 {
     LOCK(cs);
     return seenChainLocks.count(inv.hash) != 0;
 }
 
-void CChainLocksHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time)
+void ChainlockHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time)
 {
     AssertLockNotHeld(cs);
     LOCK(cs);
@@ -85,7 +85,7 @@ void CChainLocksHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const in
     }
 }
 
-MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId from, const chainlock::ChainLockSig& clsig, const llmq::CQuorumManager& qman,
+MessageProcessingResult ChainlockHandler::ProcessNewChainLock(const NodeId from, const chainlock::ChainLockSig& clsig, const llmq::CQuorumManager& qman,
                                                                 const uint256& hash)
 {
     CheckActiveState();
@@ -103,8 +103,8 @@ MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId fro
         }
     }
 
-    if (const auto ret = chainlock::VerifyChainLock(Params().GetConsensus(), m_chainman.ActiveChain(), qman, clsig); ret != VerifyRecSigStatus::Valid) {
-        LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- invalid CLSIG (%s), status=%d peer=%d\n", __func__,
+    if (const auto ret = chainlock::VerifyChainLock(Params().GetConsensus(), m_chainman.ActiveChain(), qman, clsig); ret != llmq::VerifyRecSigStatus::Valid) {
+        LogPrint(BCLog::CHAINLOCKS, "ChainlockHandler::%s -- invalid CLSIG (%s), status=%d peer=%d\n", __func__,
                  clsig.ToString(), ToUnderlying(ret), from);
         if (from != -1) {
             return MisbehavingError{10};
@@ -124,14 +124,14 @@ MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId fro
             },
             std::chrono::seconds{0});
 
-        LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- processed new CLSIG (%s), peer=%d\n", __func__,
+        LogPrint(BCLog::CHAINLOCKS, "ChainlockHandler::%s -- processed new CLSIG (%s), peer=%d\n", __func__,
                  clsig.ToString(), from);
     }
     const CInv clsig_inv(MSG_CLSIG, hash);
     return clsig_inv;
 }
 
-void CChainLocksHandler::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
+void ChainlockHandler::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
 {
     if (pindexNew == pindexFork) // blocks were disconnected without any new ones
         return;
@@ -155,7 +155,7 @@ void CChainLocksHandler::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBl
     }
 }
 
-void CChainLocksHandler::CheckActiveState()
+void ChainlockHandler::CheckActiveState()
 {
     bool oldIsEnabled = isEnabled;
     isEnabled = m_chainlocks.IsEnabled();
@@ -170,7 +170,7 @@ void CChainLocksHandler::CheckActiveState()
     }
 }
 
-void CChainLocksHandler::TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime, uint64_t)
+void ChainlockHandler::TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime, uint64_t)
 {
     if (tx->IsCoinBase() || tx->vin.empty()) {
         return;
@@ -180,12 +180,12 @@ void CChainLocksHandler::TransactionAddedToMempool(const CTransactionRef& tx, in
     txFirstSeenTime.emplace(tx->GetHash(), nAcceptTime);
 }
 
-void CChainLocksHandler::AcceptedBlockHeader(const CBlockIndex* pindexNew)
+void ChainlockHandler::AcceptedBlockHeader(const CBlockIndex* pindexNew)
 {
     m_chainlocks.AcceptedBlockHeader(pindexNew);
 }
 
-void CChainLocksHandler::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
+void ChainlockHandler::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
 {
     if (!m_mn_sync.IsBlockchainSynced()) {
         return;
@@ -203,7 +203,7 @@ void CChainLocksHandler::BlockConnected(const std::shared_ptr<const CBlock>& pbl
     }
 }
 
-bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const
+bool ChainlockHandler::IsTxSafeForMining(const uint256& txid) const
 {
     auto tx_age{0s};
     {
@@ -219,7 +219,7 @@ bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const
 
 // WARNING: cs_main and cs should not be held!
 // This should also not be called from validation signals, as this might result in recursive calls
-void CChainLocksHandler::EnforceBestChainLock()
+void ChainlockHandler::EnforceBestChainLock()
 {
     if (!isEnabled) {
         return;
@@ -240,7 +240,7 @@ void CChainLocksHandler::EnforceBestChainLock()
     // Go backwards through the chain referenced by clsig until we find a block that is part of the main chain.
     // For each of these blocks, check if there are children that are NOT part of the chain referenced by clsig
     // and mark all of them as conflicting.
-    LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- enforcing block %s via CLSIG (%s)\n", __func__,
+    LogPrint(BCLog::CHAINLOCKS, "ChainlockHandler::%s -- enforcing block %s via CLSIG (%s)\n", __func__,
              currentBestChainLockBlockIndex->GetBlockHash().ToString(), clsig.ToString());
     m_chainman.ActiveChainstate().EnforceBlock(dummy_state, currentBestChainLockBlockIndex);
 
@@ -249,7 +249,7 @@ void CChainLocksHandler::EnforceBestChainLock()
                                                      currentBestChainLockBlockIndex->nHeight)) !=
         currentBestChainLockBlockIndex) {
         if (!m_chainman.ActiveChainstate().ActivateBestChain(dummy_state)) {
-            LogPrintf("CChainLocksHandler::%s -- ActivateBestChain failed: %s\n", __func__, dummy_state.ToString());
+            LogPrintf("ChainlockHandler::%s -- ActivateBestChain failed: %s\n", __func__, dummy_state.ToString());
             return;
         }
         LOCK(::cs_main);
@@ -270,7 +270,7 @@ void CChainLocksHandler::EnforceBestChainLock()
     ::g_stats_client->gauge("chainlocks.blockHeight", clsig.getHeight(), 1.0f);
 }
 
-void CChainLocksHandler::CleanupFromSigner(const std::vector<std::shared_ptr<Uint256HashSet>>& cleanup_txes)
+void ChainlockHandler::CleanupFromSigner(const std::vector<std::shared_ptr<Uint256HashSet>>& cleanup_txes)
 {
     LOCK(cs);
     for (const auto& tx : cleanup_txes) {
@@ -280,7 +280,7 @@ void CChainLocksHandler::CleanupFromSigner(const std::vector<std::shared_ptr<Uin
     }
 }
 
-void CChainLocksHandler::Cleanup()
+void ChainlockHandler::Cleanup()
 {
     constexpr auto CLEANUP_INTERVAL{30s};
     if (!m_mn_sync.IsBlockchainSynced()) {
@@ -324,10 +324,7 @@ void CChainLocksHandler::Cleanup()
         }
     }
 }
-} // namespace llmq
 
-namespace chainlock
-{
 llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain, const llmq::CQuorumManager& qman, const chainlock::ChainLockSig& clsig)
 {
     const auto llmqType = params.llmqTypeChainLocks;
diff --git a/src/chainlock/handler.h b/src/chainlock/handler.h
@@ -31,10 +31,6 @@ class CScheduler;
 class CTxMemPool;
 struct MessageProcessingResult;
 
-namespace chainlock {
-class Chainlocks;
-struct ChainLockSig;
-} // namespace chainlock
 namespace Consensus {
 struct Params;
 } // namespace Consensus
@@ -43,8 +39,13 @@ namespace llmq
 {
 class CQuorumManager;
 enum class VerifyRecSigStatus : uint8_t;
+} // namespace llmq
 
-class CChainLocksHandler final : public CValidationInterface
+namespace chainlock {
+class Chainlocks;
+struct ChainLockSig;
+
+class ChainlockHandler final : public CValidationInterface
 {
 private:
     chainlock::Chainlocks& m_chainlocks;
@@ -67,12 +68,12 @@ class CChainLocksHandler final : public CValidationInterface
     CleanupThrottler<NodeClock> cleanupThrottler;
 
 public:
-    CChainLocksHandler() = delete;
-    CChainLocksHandler(const CChainLocksHandler&) = delete;
-    CChainLocksHandler& operator=(const CChainLocksHandler&) = delete;
-    explicit CChainLocksHandler(chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,
+    ChainlockHandler() = delete;
+    ChainlockHandler(const ChainlockHandler&) = delete;
+    ChainlockHandler& operator=(const ChainlockHandler&) = delete;
+    explicit ChainlockHandler(chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,
                                 CTxMemPool& _mempool, const CMasternodeSync& mn_sync);
-    ~CChainLocksHandler();
+    ~ChainlockHandler();
 
     void Start();
     void Stop();
@@ -111,10 +112,7 @@ class CChainLocksHandler final : public CValidationInterface
     void Cleanup()
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 };
-} // namespace llmq
 
-namespace chainlock
-{
 llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain, const llmq::CQuorumManager& qman, const chainlock::ChainLockSig& clsig);
 } // namespace chainlock
 
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
@@ -20,7 +20,7 @@
 using node::ReadBlockFromDisk;
 
 namespace chainlock {
-ChainLockSigner::ChainLockSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks, llmq::CChainLocksHandler& clhandler, const llmq::CInstantSendManager& isman, const llmq::CQuorumManager& qman,
+ChainLockSigner::ChainLockSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks, ChainlockHandler& clhandler, const llmq::CInstantSendManager& isman, const llmq::CQuorumManager& qman,
                                  llmq::CSigningManager& sigman, llmq::CSigSharesManager& shareman,
                                  const CMasternodeSync& mn_sync) :
     m_chainstate{chainstate},
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
@@ -15,21 +15,21 @@ class CScheduler;
 class CMasternodeSync;
 struct MessageProcessingResult;
 namespace llmq {
-class CChainLocksHandler;
 class CInstantSendManager;
 class CRecoveredSig;
 class CSigningManager;
 class CSigSharesManager;
 } // namespace llmq
 
 namespace chainlock {
-class ChainLockSigner final : public llmq::CRecoveredSigsListener, public CValidationInterface
+class ChainlockHandler;
 
+class ChainLockSigner final : public llmq::CRecoveredSigsListener, public CValidationInterface
 {
 private:
     CChainState& m_chainstate;
     const chainlock::Chainlocks& m_chainlocks;
-    llmq::CChainLocksHandler& m_clhandler;
+    ChainlockHandler& m_clhandler;
     const llmq::CInstantSendManager& m_isman;
     const llmq::CQuorumManager& m_qman;
     llmq::CSigningManager& m_sigman;
@@ -59,7 +59,7 @@ class ChainLockSigner final : public llmq::CRecoveredSigsListener, public CValid
     ChainLockSigner() = delete;
     ChainLockSigner(const ChainLockSigner&) = delete;
     ChainLockSigner& operator=(const ChainLockSigner&) = delete;
-    explicit ChainLockSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks, llmq::CChainLocksHandler& clhandler, const llmq::CInstantSendManager& isman, const llmq::CQuorumManager& qman, llmq::CSigningManager& sigman,
+    explicit ChainLockSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks, ChainlockHandler& clhandler, const llmq::CInstantSendManager& isman, const llmq::CQuorumManager& qman, llmq::CSigningManager& sigman,
                              llmq::CSigSharesManager& shareman, const CMasternodeSync& mn_sync);
     ~ChainLockSigner();
 
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
@@ -27,7 +27,7 @@ CChainstateHelper::CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministi
 
 CChainstateHelper::~CChainstateHelper() = default;
 
-/** Passthrough functions to CChainLocksHandler */
+/** Passthrough functions to chainlock::Chainlocks */
 bool CChainstateHelper::HasConflictingChainLock(int nHeight, const uint256& blockHash) const
 {
     return m_chainlocks.HasConflictingChainLock(nHeight, blockHash);
diff --git a/src/init.cpp b/src/init.cpp
@@ -2171,7 +2171,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     assert(!node.dstxman);
     node.dstxman = std::make_unique<CDSTXManager>(*node.chainlocks);
 
-    node.clhandler = std::make_unique<llmq::CChainLocksHandler>(*node.chainlocks, chainman, *node.mempool, *node.mn_sync);
+    node.clhandler = std::make_unique<chainlock::ChainlockHandler>(*node.chainlocks, chainman, *node.mempool, *node.mn_sync);
     RegisterValidationInterface(node.clhandler.get());
 
     assert(!node.peerman);
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
@@ -604,7 +604,7 @@ void CInstantSendManager::ResolveBlockConflicts(const uint256& islockHash, const
     if (activateBestChain) {
         BlockValidationState state;
         if (!m_chainstate.ActivateBestChain(state)) {
-            LogPrintf("CChainLocksHandler::%s -- ActivateBestChain failed: %s\n", __func__, state.ToString());
+            LogPrintf("CInstantSendManager::%s -- ActivateBestChain failed: %s\n", __func__, state.ToString());
             // This should not have happened and we are in a state were it's not safe to continue anymore
             assert(false);
         }
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -588,7 +588,7 @@ class PeerManagerImpl final : public PeerManager
                     CDSTXManager& dstxman, ChainstateManager& chainman, CTxMemPool& pool,
                     CMasternodeMetaMan& mn_metaman, CMasternodeSync& mn_sync, CGovernanceManager& govman,
                     CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                    llmq::CChainLocksHandler& clhandler,
+                    chainlock::ChainlockHandler& clhandler,
                     const std::unique_ptr<ActiveContext>& active_ctx,
                     const std::unique_ptr<CDeterministicMNManager>& dmnman,
                     const std::unique_ptr<CJWalletManager>& cj_walletman,
@@ -823,8 +823,8 @@ class PeerManagerImpl final : public PeerManager
     CGovernanceManager& m_govman;
     CSporkManager& m_sporkman;
     const chainlock::Chainlocks& m_chainlocks;
-    // TODO: consider further refactoring CChainLocksHandler to NetHandler to avoid boiler code in PeerManager
-    llmq::CChainLocksHandler& m_clhandler;
+    // TODO: consider further refactoring ChainlockHandler to NetHandler to avoid boiler code in PeerManager
+    chainlock::ChainlockHandler& m_clhandler;
 
     /** The height of the best chain */
     std::atomic<int> m_best_height{-1};
@@ -2048,7 +2048,7 @@ std::unique_ptr<PeerManager> PeerManager::make(const CChainParams& chainparams,
                                                CTxMemPool& pool, CMasternodeMetaMan& mn_metaman,
                                                CMasternodeSync& mn_sync, CGovernanceManager& govman,
                                                CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                                               llmq::CChainLocksHandler& clhandler,
+                                               chainlock::ChainlockHandler& clhandler,
                                                const std::unique_ptr<ActiveContext>& active_ctx,
                                                const std::unique_ptr<CDeterministicMNManager>& dmnman,
                                                const std::unique_ptr<CJWalletManager>& cj_walletman,
@@ -2063,7 +2063,7 @@ PeerManagerImpl::PeerManagerImpl(const CChainParams& chainparams, CConnman& conn
                                  CMasternodeMetaMan& mn_metaman, CMasternodeSync& mn_sync, CGovernanceManager& govman,
                                  CSporkManager& sporkman,
                                  const chainlock::Chainlocks& chainlocks,
-                                 llmq::CChainLocksHandler& clhandler,
+                                 chainlock::ChainlockHandler& clhandler,
                                  const std::unique_ptr<ActiveContext>& active_ctx,
                                  const std::unique_ptr<CDeterministicMNManager>& dmnman,
                                  const std::unique_ptr<CJWalletManager>& cj_walletman,
diff --git a/src/net_processing.h b/src/net_processing.h
diff --git a/src/node/context.h b/src/node/context.h
diff --git a/src/node/miner.h b/src/node/miner.h
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp

Original file line number	Diff line number	Diff line change
`@@ -29,14 +29,14 @@ CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMe`
`29`	`29`
`30`	`30`	`using node::GetTransaction;`
`31`	`31`
`32`		`-namespace llmq {`
`33`	`32`	`namespace {`
`34`	`33`	`static constexpr auto CLEANUP_SEEN_TIMEOUT{24h};`
`35`	`34`	`//! How long to wait for islocks until we consider a block with non-islocked TXs to be safe to sign`
`36`	`35`	`static constexpr auto WAIT_FOR_ISLOCK_TIMEOUT{10min};`
`37`	`36`	`} // anonymous namespace`
`38`	`37`
`39`		`-CChainLocksHandler::CChainLocksHandler(chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,`
	`38`	`+namespace chainlock {`
	`39`	`+ChainlockHandler::ChainlockHandler(chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,`
`40`	`40`	`CTxMemPool& _mempool, const CMasternodeSync& mn_sync) :`
`41`	`41`	`m_chainlocks{chainlocks},`
`42`	`42`	`m_chainman{chainman},`
`@@ -48,13 +48,13 @@ CChainLocksHandler::CChainLocksHandler(chainlock::Chainlocks& chainlocks, Chains`
`48`	`48`	`{`
`49`	`49`	`}`
`50`	`50`
`51`		`-CChainLocksHandler::~CChainLocksHandler()`
	`51`	`+ChainlockHandler::~ChainlockHandler()`
`52`	`52`	`{`
`53`	`53`	`scheduler->stop();`
`54`	`54`	`scheduler_thread->join();`
`55`	`55`	`}`
`56`	`56`
`57`		`-void CChainLocksHandler::Start()`
	`57`	`+void ChainlockHandler::Start()`
`58`	`58`	`{`
`59`	`59`	`scheduler->scheduleEvery(`
`60`	`60`	`[&]() {`
`@@ -65,18 +65,18 @@ void CChainLocksHandler::Start()`
`65`	`65`	`std::chrono::seconds{5});`
`66`	`66`	`}`
`67`	`67`
`68`		`-void CChainLocksHandler::Stop()`
	`68`	`+void ChainlockHandler::Stop()`
`69`	`69`	`{`
`70`	`70`	`scheduler->stop();`
`71`	`71`	`}`
`72`	`72`
`73`		`-bool CChainLocksHandler::AlreadyHave(const CInv& inv) const`
	`73`	`+bool ChainlockHandler::AlreadyHave(const CInv& inv) const`
`74`	`74`	`{`
`75`	`75`	`LOCK(cs);`
`76`	`76`	`return seenChainLocks.count(inv.hash) != 0;`
`77`	`77`	`}`
`78`	`78`
`79`		`-void CChainLocksHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time)`
	`79`	`+void ChainlockHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const int64_t& time)`
`80`	`80`	`{`
`81`	`81`	`AssertLockNotHeld(cs);`
`82`	`82`	`LOCK(cs);`
`@@ -85,7 +85,7 @@ void CChainLocksHandler::UpdateTxFirstSeenMap(const Uint256HashSet& tx, const in`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`88`		`-MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId from, const chainlock::ChainLockSig& clsig, const llmq::CQuorumManager& qman,`
	`88`	`+MessageProcessingResult ChainlockHandler::ProcessNewChainLock(const NodeId from, const chainlock::ChainLockSig& clsig, const llmq::CQuorumManager& qman,`
`89`	`89`	`const uint256& hash)`
`90`	`90`	`{`
`91`	`91`	`CheckActiveState();`
`@@ -103,8 +103,8 @@ MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId fro`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`		`- if (const auto ret = chainlock::VerifyChainLock(Params().GetConsensus(), m_chainman.ActiveChain(), qman, clsig); ret != VerifyRecSigStatus::Valid) {`
`107`		`- LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- invalid CLSIG (%s), status=%d peer=%d\n", __func__,`
	`106`	`+ if (const auto ret = chainlock::VerifyChainLock(Params().GetConsensus(), m_chainman.ActiveChain(), qman, clsig); ret != llmq::VerifyRecSigStatus::Valid) {`
	`107`	`+ LogPrint(BCLog::CHAINLOCKS, "ChainlockHandler::%s -- invalid CLSIG (%s), status=%d peer=%d\n", __func__,`
`108`	`108`	`clsig.ToString(), ToUnderlying(ret), from);`
`109`	`109`	`if (from != -1) {`
`110`	`110`	`return MisbehavingError{10};`
`@@ -124,14 +124,14 @@ MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId fro`
`124`	`124`	`},`
`125`	`125`	`std::chrono::seconds{0});`
`126`	`126`
`127`		`- LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- processed new CLSIG (%s), peer=%d\n", __func__,`
	`127`	`+ LogPrint(BCLog::CHAINLOCKS, "ChainlockHandler::%s -- processed new CLSIG (%s), peer=%d\n", __func__,`
`128`	`128`	`clsig.ToString(), from);`
`129`	`129`	`}`
`130`	`130`	`const CInv clsig_inv(MSG_CLSIG, hash);`
`131`	`131`	`return clsig_inv;`
`132`	`132`	`}`
`133`	`133`
`134`		`-void CChainLocksHandler::UpdatedBlockTip(const CBlockIndex pindexNew, const CBlockIndex pindexFork, bool fInitialDownload)`
	`134`	`+void ChainlockHandler::UpdatedBlockTip(const CBlockIndex pindexNew, const CBlockIndex pindexFork, bool fInitialDownload)`
`135`	`135`	`{`
`136`	`136`	`if (pindexNew == pindexFork) // blocks were disconnected without any new ones`
`137`	`137`	`return;`
`@@ -155,7 +155,7 @@ void CChainLocksHandler::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBl`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`
`158`		`-void CChainLocksHandler::CheckActiveState()`
	`158`	`+void ChainlockHandler::CheckActiveState()`
`159`	`159`	`{`
`160`	`160`	`bool oldIsEnabled = isEnabled;`
`161`	`161`	`isEnabled = m_chainlocks.IsEnabled();`
`@@ -170,7 +170,7 @@ void CChainLocksHandler::CheckActiveState()`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`
`173`		`-void CChainLocksHandler::TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime, uint64_t)`
	`173`	`+void ChainlockHandler::TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime, uint64_t)`
`174`	`174`	`{`
`175`	`175`	`if (tx->IsCoinBase() \|\| tx->vin.empty()) {`
`176`	`176`	`return;`
`@@ -180,12 +180,12 @@ void CChainLocksHandler::TransactionAddedToMempool(const CTransactionRef& tx, in`
`180`	`180`	`txFirstSeenTime.emplace(tx->GetHash(), nAcceptTime);`
`181`	`181`	`}`
`182`	`182`
`183`		`-void CChainLocksHandler::AcceptedBlockHeader(const CBlockIndex* pindexNew)`
	`183`	`+void ChainlockHandler::AcceptedBlockHeader(const CBlockIndex* pindexNew)`
`184`	`184`	`{`
`185`	`185`	`m_chainlocks.AcceptedBlockHeader(pindexNew);`
`186`	`186`	`}`
`187`	`187`
`188`		`-void CChainLocksHandler::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)`
	`188`	`+void ChainlockHandler::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)`
`189`	`189`	`{`
`190`	`190`	`if (!m_mn_sync.IsBlockchainSynced()) {`
`191`	`191`	`return;`
`@@ -203,7 +203,7 @@ void CChainLocksHandler::BlockConnected(const std::shared_ptr<const CBlock>& pbl`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
`206`		`-bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const`
	`206`	`+bool ChainlockHandler::IsTxSafeForMining(const uint256& txid) const`
`207`	`207`	`{`
`208`	`208`	`auto tx_age{0s};`
`209`	`209`	`{`
`@@ -219,7 +219,7 @@ bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const`
`219`	`219`
`220`	`220`	`// WARNING: cs_main and cs should not be held!`
`221`	`221`	`// This should also not be called from validation signals, as this might result in recursive calls`
`222`		`-void CChainLocksHandler::EnforceBestChainLock()`
	`222`	`+void ChainlockHandler::EnforceBestChainLock()`
`223`	`223`	`{`
`224`	`224`	`if (!isEnabled) {`
`225`	`225`	`return;`
`@@ -240,7 +240,7 @@ void CChainLocksHandler::EnforceBestChainLock()`
`240`	`240`	`// Go backwards through the chain referenced by clsig until we find a block that is part of the main chain.`
`241`	`241`	`// For each of these blocks, check if there are children that are NOT part of the chain referenced by clsig`
`242`	`242`	`// and mark all of them as conflicting.`
`243`		`- LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- enforcing block %s via CLSIG (%s)\n", __func__,`
	`243`	`+ LogPrint(BCLog::CHAINLOCKS, "ChainlockHandler::%s -- enforcing block %s via CLSIG (%s)\n", __func__,`
`244`	`244`	`currentBestChainLockBlockIndex->GetBlockHash().ToString(), clsig.ToString());`
`245`	`245`	`m_chainman.ActiveChainstate().EnforceBlock(dummy_state, currentBestChainLockBlockIndex);`
`246`	`246`
`@@ -249,7 +249,7 @@ void CChainLocksHandler::EnforceBestChainLock()`
`249`	`249`	`currentBestChainLockBlockIndex->nHeight)) !=`
`250`	`250`	`currentBestChainLockBlockIndex) {`
`251`	`251`	`if (!m_chainman.ActiveChainstate().ActivateBestChain(dummy_state)) {`
`252`		`- LogPrintf("CChainLocksHandler::%s -- ActivateBestChain failed: %s\n", __func__, dummy_state.ToString());`
	`252`	`+ LogPrintf("ChainlockHandler::%s -- ActivateBestChain failed: %s\n", __func__, dummy_state.ToString());`
`253`	`253`	`return;`
`254`	`254`	`}`
`255`	`255`	`LOCK(::cs_main);`
`@@ -270,7 +270,7 @@ void CChainLocksHandler::EnforceBestChainLock()`
`270`	`270`	`::g_stats_client->gauge("chainlocks.blockHeight", clsig.getHeight(), 1.0f);`
`271`	`271`	`}`
`272`	`272`
`273`		`-void CChainLocksHandler::CleanupFromSigner(const std::vector<std::shared_ptr<Uint256HashSet>>& cleanup_txes)`
	`273`	`+void ChainlockHandler::CleanupFromSigner(const std::vector<std::shared_ptr<Uint256HashSet>>& cleanup_txes)`
`274`	`274`	`{`
`275`	`275`	`LOCK(cs);`
`276`	`276`	`for (const auto& tx : cleanup_txes) {`
`@@ -280,7 +280,7 @@ void CChainLocksHandler::CleanupFromSigner(const std::vector<std::shared_ptr<Uin`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`
`283`		`-void CChainLocksHandler::Cleanup()`
	`283`	`+void ChainlockHandler::Cleanup()`
`284`	`284`	`{`
`285`	`285`	`constexpr auto CLEANUP_INTERVAL{30s};`
`286`	`286`	`if (!m_mn_sync.IsBlockchainSynced()) {`
`@@ -324,10 +324,7 @@ void CChainLocksHandler::Cleanup()`
`324`	`324`	`}`
`325`	`325`	`}`
`326`	`326`	`}`
`327`		`-} // namespace llmq`
`328`	`327`
`329`		`-namespace chainlock`
`330`		`-{`
`331`	`328`	`llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain, const llmq::CQuorumManager& qman, const chainlock::ChainLockSig& clsig)`
`332`	`329`	`{`
`333`	`330`	`const auto llmqType = params.llmqTypeChainLocks;`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ CChainstateHelper::CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministi`
`27`	`27`
`28`	`28`	`CChainstateHelper::~CChainstateHelper() = default;`
`29`	`29`
`30`		`-/** Passthrough functions to CChainLocksHandler */`
	`30`	`+/** Passthrough functions to chainlock::Chainlocks */`
`31`	`31`	`bool CChainstateHelper::HasConflictingChainLock(int nHeight, const uint256& blockHash) const`
`32`	`32`	`{`
`33`	`33`	`return m_chainlocks.HasConflictingChainLock(nHeight, blockHash);`
Original file line number	Diff line number	Diff line change
`@@ -604,7 +604,7 @@ void CInstantSendManager::ResolveBlockConflicts(const uint256& islockHash, const`
`604`	`604`	`if (activateBestChain) {`
`605`	`605`	`BlockValidationState state;`
`606`	`606`	`if (!m_chainstate.ActivateBestChain(state)) {`
`607`		`- LogPrintf("CChainLocksHandler::%s -- ActivateBestChain failed: %s\n", __func__, state.ToString());`
	`607`	`+ LogPrintf("CInstantSendManager::%s -- ActivateBestChain failed: %s\n", __func__, state.ToString());`
`608`	`608`	`// This should not have happened and we are in a state were it's not safe to continue anymore`
`609`	`609`	`assert(false);`
`610`	`610`	`}`