diff --git a/src/Makefile.am b/src/Makefile.am
index 55c8f03ae4750..1f1cddf3f856a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -150,6 +150,9 @@ BITCOIN_CORE_H = \
   cachemultimap.h \
   blockfilter.h \
   chain.h \
+  chainlock/chainlock.h \
+  chainlock/clsig.h \
+  chainlock/signing.h \
   chainparams.h \
   chainparamsbase.h \
   chainparamsseeds.h \
@@ -239,8 +242,6 @@ BITCOIN_CORE_H = \
   key_io.h \
   limitedmap.h \
   llmq/blockprocessor.h \
-  llmq/chainlocks.h \
-  llmq/clsig.h \
   llmq/commitment.h \
   llmq/context.h \
   llmq/debug.h \
@@ -455,6 +456,9 @@ libbitcoin_node_a_SOURCES = \
   blockencodings.cpp \
   blockfilter.cpp \
   chain.cpp \
+  chainlock/chainlock.cpp \
+  chainlock/clsig.cpp \
+  chainlock/signing.cpp \
   coinjoin/coinjoin.cpp \
   coinjoin/context.cpp \
   coinjoin/server.cpp \
@@ -498,8 +502,6 @@ libbitcoin_node_a_SOURCES = \
   instantsend/lock.cpp \
   instantsend/signing.cpp \
   llmq/blockprocessor.cpp \
-  llmq/chainlocks.cpp \
-  llmq/clsig.cpp \
   llmq/commitment.cpp \
   llmq/context.cpp \
   llmq/debug.cpp \
diff --git a/src/bench/rpc_blockchain.cpp b/src/bench/rpc_blockchain.cpp
index 33fc11065d894..9ed1fffb2f780 100644
--- a/src/bench/rpc_blockchain.cpp
+++ b/src/bench/rpc_blockchain.cpp
@@ -5,9 +5,9 @@
 #include <bench/bench.h>
 #include <bench/data.h>
 
+#include <chainlock/chainlock.h>
 #include <consensus/validation.h>
 #include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <rpc/blockchain.h>
 #include <streams.h>
diff --git a/src/llmq/chainlocks.cpp b/src/chainlock/chainlock.cpp
similarity index 58%
rename from src/llmq/chainlocks.cpp
rename to src/chainlock/chainlock.cpp
index 155e1117260a5..ea1d179dbd312 100644
--- a/src/llmq/chainlocks.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -2,19 +2,13 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <llmq/chainlocks.h>
-#include <llmq/quorums.h>
+#include <chainlock/chainlock.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <instantsend/instantsend.h>
-#include <masternode/sync.h>
-#include <node/blockstorage.h>
 #include <node/interface_ui.h>
 #include <scheduler.h>
-#include <spork.h>
-#include <stats/client.h>
 #include <txmempool.h>
 #include <util/thread.h>
 #include <util/time.h>
@@ -22,37 +16,47 @@
 #include <validation.h>
 #include <validationinterface.h>
 
-using node::ReadBlockFromDisk;
+#include <instantsend/instantsend.h>
+#include <llmq/quorums.h>
+#include <masternode/sync.h>
+#include <spork.h>
+#include <stats/client.h>
 
 // Forward declaration to break dependency over node/transaction.h
-namespace node
-{
+namespace node {
 CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
                                const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
 } // namespace node
+
 using node::GetTransaction;
 
-static bool ChainLocksSigningEnabled(const CSporkManager& sporkman)
+namespace llmq {
+namespace {
+static constexpr int64_t CLEANUP_INTERVAL{1000 * 30};
+static constexpr int64_t CLEANUP_SEEN_TIMEOUT{24 * 60 * 60 * 1000};
+//! How long to wait for islocks until we consider a block with non-islocked TXs to be safe to sign
+static constexpr int64_t WAIT_FOR_ISLOCK_TIMEOUT{10 * 60};
+} // anonymous namespace
+
+bool AreChainLocksEnabled(const CSporkManager& sporkman)
 {
-    return sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) == 0;
+    return sporkman.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
 }
 
-namespace llmq
-{
 CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
                                        CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
                                        const CMasternodeSync& mn_sync, bool is_masternode) :
-    m_chainstate(chainstate),
-    qman(_qman),
-    sigman(_sigman),
-    shareman(_shareman),
-    spork_manager(sporkman),
-    mempool(_mempool),
-    m_mn_sync(mn_sync),
-    m_is_masternode{is_masternode},
-    scheduler(std::make_unique<CScheduler>()),
-    scheduler_thread(
-        std::make_unique<std::thread>(std::thread(util::TraceThread, "cl-schdlr", [&] { scheduler->serviceQueue(); })))
+    m_chainstate{chainstate},
+    qman{_qman},
+    spork_manager{sporkman},
+    mempool{_mempool},
+    m_mn_sync{mn_sync},
+    scheduler{std::make_unique<CScheduler>()},
+    scheduler_thread{
+        std::make_unique<std::thread>(std::thread(util::TraceThread, "cl-schdlr", [&] { scheduler->serviceQueue(); }))},
+    m_signer{is_masternode
+                 ? std::make_unique<chainlock::ChainLockSigner>(chainstate, *this, _sigman, _shareman, sporkman, mn_sync)
+                 : nullptr}
 {
 }
 
@@ -64,19 +68,26 @@ CChainLocksHandler::~CChainLocksHandler()
 
 void CChainLocksHandler::Start(const llmq::CInstantSendManager& isman)
 {
-    sigman.RegisterRecoveredSigsListener(this);
+    if (m_signer) {
+        m_signer->Start();
+    }
     scheduler->scheduleEvery([&]() {
         CheckActiveState();
         EnforceBestChainLock();
+        Cleanup();
         // regularly retry signing the current chaintip as it might have failed before due to missing islocks
-        TrySignChainTip(isman);
+        if (m_signer) {
+            m_signer->TrySignChainTip(isman);
+        }
     }, std::chrono::seconds{5});
 }
 
 void CChainLocksHandler::Stop()
 {
     scheduler->stop();
-    sigman.UnregisterRecoveredSigsListener(this);
+    if (m_signer) {
+        m_signer->Stop();
+    }
 }
 
 bool CChainLocksHandler::AlreadyHave(const CInv& inv) const
@@ -85,7 +96,7 @@ bool CChainLocksHandler::AlreadyHave(const CInv& inv) const
     return seenChainLocks.count(inv.hash) != 0;
 }
 
-bool CChainLocksHandler::GetChainLockByHash(const uint256& hash, llmq::CChainLockSig& ret) const
+bool CChainLocksHandler::GetChainLockByHash(const uint256& hash, chainlock::ChainLockSig& ret) const
 {
     LOCK(cs);
 
@@ -98,13 +109,22 @@ bool CChainLocksHandler::GetChainLockByHash(const uint256& hash, llmq::CChainLoc
     return true;
 }
 
-CChainLockSig CChainLocksHandler::GetBestChainLock() const
+chainlock::ChainLockSig CChainLocksHandler::GetBestChainLock() const
 {
     LOCK(cs);
     return bestChainLock;
 }
 
-MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CChainLockSig& clsig,
+void CChainLocksHandler::UpdateTxFirstSeenMap(const std::unordered_set<uint256, StaticSaltedHasher>& tx, const int64_t& time)
+{
+    AssertLockNotHeld(cs);
+    LOCK(cs);
+    for (const auto& txid : tx) {
+        txFirstSeenTime.emplace(txid, time);
+    }
+}
+
+MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId from, const chainlock::ChainLockSig& clsig,
                                                                 const uint256& hash)
 {
     CheckActiveState();
@@ -203,7 +223,10 @@ void CChainLocksHandler::UpdatedBlockTip(const llmq::CInstantSendManager& isman)
         scheduler->scheduleFromNow([&]() {
             CheckActiveState();
             EnforceBestChainLock();
-            TrySignChainTip(isman);
+            Cleanup();
+            if (m_signer) {
+                m_signer->TrySignChainTip(isman);
+            }
             tryLockChainTipScheduled = false;
         }, std::chrono::seconds{0});
     }
@@ -220,127 +243,11 @@ void CChainLocksHandler::CheckActiveState()
         // to disable spork19)
         LOCK(cs);
         bestChainLockHash = uint256();
-        bestChainLock = bestChainLockWithKnownBlock = CChainLockSig();
+        bestChainLock = bestChainLockWithKnownBlock = chainlock::ChainLockSig();
         bestChainLockBlockIndex = lastNotifyChainLockBlockIndex = nullptr;
     }
 }
 
-void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
-{
-    Cleanup();
-
-    if (!m_is_masternode) {
-        return;
-    }
-
-    if (!m_mn_sync.IsBlockchainSynced()) {
-        return;
-    }
-
-    if (!isEnabled) {
-        return;
-    }
-
-    if (!ChainLocksSigningEnabled(spork_manager)) {
-        return;
-    }
-
-    const CBlockIndex* pindex = WITH_LOCK(::cs_main, return m_chainstate.m_chain.Tip());
-
-    if (pindex->pprev == nullptr) {
-        return;
-    }
-
-    // DIP8 defines a process called "Signing attempts" which should run before the CLSIG is finalized
-    // To simplify the initial implementation, we skip this process and directly try to create a CLSIG
-    // This will fail when multiple blocks compete, but we accept this for the initial implementation.
-    // Later, we'll add the multiple attempts process.
-
-    {
-        LOCK(cs);
-
-        if (pindex->nHeight == lastSignedHeight) {
-            // already signed this one
-            return;
-        }
-
-        if (bestChainLock.getHeight() >= pindex->nHeight) {
-            // already got the same CLSIG or a better one
-            return;
-        }
-
-        if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            // don't sign if another conflicting CLSIG is already present. EnforceBestChainLock will later enforce
-            // the correct chain.
-            return;
-        }
-    }
-
-    LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- trying to sign %s, height=%d\n", __func__, pindex->GetBlockHash().ToString(), pindex->nHeight);
-
-    // When the new IX system is activated, we only try to ChainLock blocks which include safe transactions. A TX is
-    // considered safe when it is islocked or at least known since 10 minutes (from mempool or block). These checks are
-    // performed for the tip (which we try to sign) and the previous 5 blocks. If a ChainLocked block is found on the
-    // way down, we consider all TXs to be safe.
-    if (isman.IsInstantSendEnabled() && isman.RejectConflictingBlocks()) {
-        const auto* pindexWalk = pindex;
-        while (pindexWalk != nullptr) {
-            if (pindex->nHeight - pindexWalk->nHeight > 5) {
-                // no need to check further down, 6 confs is safe to assume that TXs below this height won't be
-                // islocked anymore if they aren't already
-                LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- tip and previous 5 blocks all safe\n", __func__);
-                break;
-            }
-            if (HasChainLock(pindexWalk->nHeight, pindexWalk->GetBlockHash())) {
-                // we don't care about islocks for TXs that are ChainLocked already
-                LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- chainlock at height %d\n", __func__, pindexWalk->nHeight);
-                break;
-            }
-
-            auto txids = GetBlockTxs(pindexWalk->GetBlockHash());
-            if (!txids) {
-                pindexWalk = pindexWalk->pprev;
-                continue;
-            }
-
-            for (const auto& txid : *txids) {
-                int64_t txAge = 0;
-                {
-                    LOCK(cs);
-                    auto it = txFirstSeenTime.find(txid);
-                    if (it != txFirstSeenTime.end()) {
-                        txAge = GetTime<std::chrono::seconds>().count() - it->second;
-                    }
-                }
-
-                if (txAge < WAIT_FOR_ISLOCK_TIMEOUT && !isman.IsLocked(txid)) {
-                    LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- not signing block %s due to TX %s not being islocked and not old enough. age=%d\n", __func__,
-                              pindexWalk->GetBlockHash().ToString(), txid.ToString(), txAge);
-                    return;
-                }
-            }
-
-            pindexWalk = pindexWalk->pprev;
-        }
-    }
-
-    uint256 requestId = ::SerializeHash(std::make_pair(CLSIG_REQUESTID_PREFIX, pindex->nHeight));
-    uint256 msgHash = pindex->GetBlockHash();
-
-    {
-        LOCK(cs);
-        if (bestChainLock.getHeight() >= pindex->nHeight) {
-            // might have happened while we didn't hold cs
-            return;
-        }
-        lastSignedHeight = pindex->nHeight;
-        lastSignedRequestId = requestId;
-        lastSignedMsgHash = msgHash;
-    }
-
-    sigman.AsyncSignIfMember(Params().GetConsensus().llmqTypeChainLocks, shareman, requestId, msgHash);
-}
-
 void CChainLocksHandler::TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime)
 {
     if (tx->IsCoinBase() || tx->vin.empty()) {
@@ -358,85 +265,34 @@ void CChainLocksHandler::BlockConnected(const std::shared_ptr<const CBlock>& pbl
     }
 
     // We listen for BlockConnected so that we can collect all TX ids of all included TXs of newly received blocks
-    // We need this information later when we try to sign a new tip, so that we can determine if all included TXs are
-    // safe.
-
-    LOCK(cs);
-
-    auto it = blockTxs.find(pindex->GetBlockHash());
-    if (it == blockTxs.end()) {
-        // we must create this entry even if there are no lockable transactions in the block, so that TrySignChainTip
-        // later knows about this block
-        it = blockTxs.emplace(pindex->GetBlockHash(), std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>()).first;
-    }
-    auto& txids = *it->second;
-
     int64_t curTime = GetTime<std::chrono::seconds>().count();
-
-    for (const auto& tx : pblock->vtx) {
-        if (tx->IsCoinBase() || tx->vin.empty()) {
-            continue;
+    {
+        LOCK(cs);
+        for (const auto& tx : pblock->vtx) {
+            if (!tx->IsCoinBase() && !tx->vin.empty()) {
+                txFirstSeenTime.emplace(tx->GetHash(), curTime);
+            }
         }
-
-        txids.emplace(tx->GetHash());
-        txFirstSeenTime.emplace(tx->GetHash(), curTime);
     }
 
+    // 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);
+    }
 }
 
 void CChainLocksHandler::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, gsl::not_null<const CBlockIndex*> pindexDisconnected)
 {
-    LOCK(cs);
-    blockTxs.erase(pindexDisconnected->GetBlockHash());
+    if (m_signer) {
+        m_signer->EraseFromBlockHashTxidMap(pindexDisconnected->GetBlockHash());
+    }
 }
 
-CChainLocksHandler::BlockTxs::mapped_type CChainLocksHandler::GetBlockTxs(const uint256& blockHash)
+int32_t CChainLocksHandler::GetBestChainLockHeight() const
 {
     AssertLockNotHeld(cs);
-    AssertLockNotHeld(cs_main);
-
-    CChainLocksHandler::BlockTxs::mapped_type ret;
-
-    {
-        LOCK(cs);
-        auto it = blockTxs.find(blockHash);
-        if (it != blockTxs.end()) {
-            ret = it->second;
-        }
-    }
-    if (!ret) {
-        // This should only happen when freshly started.
-        // If running for some time, SyncTransaction should have been called before which fills blockTxs.
-        LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- blockTxs for %s not found. Trying ReadBlockFromDisk\n", __func__,
-                 blockHash.ToString());
-
-        uint32_t blockTime;
-        {
-            LOCK(::cs_main);
-            const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(blockHash);
-            CBlock block;
-            if (!ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
-                return nullptr;
-            }
-
-            ret = std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>();
-            for (const auto& tx : block.vtx) {
-                if (tx->IsCoinBase() || tx->vin.empty()) {
-                    continue;
-                }
-                ret->emplace(tx->GetHash());
-            }
-
-            blockTime = block.nTime;
-        }
-
-        LOCK(cs);
-        blockTxs.emplace(blockHash, ret);
-        for (const auto& txid : *ret) {
-            txFirstSeenTime.emplace(txid, blockTime);
-        }
-    }
-    return ret;
+    LOCK(cs);
+    return bestChainLock.getHeight();
 }
 
 bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const
@@ -460,17 +316,17 @@ void CChainLocksHandler::EnforceBestChainLock()
     AssertLockNotHeld(cs);
     AssertLockNotHeld(cs_main);
 
-    std::shared_ptr<CChainLockSig> clsig;
+    std::shared_ptr<chainlock::ChainLockSig> clsig;
     const CBlockIndex* pindex;
     const CBlockIndex* currentBestChainLockBlockIndex;
     {
         LOCK(cs);
 
-        if (!isEnabled) {
+        if (!IsEnabled()) {
             return;
         }
 
-        clsig = std::make_shared<CChainLockSig>(bestChainLockWithKnownBlock);
+        clsig = std::make_shared<chainlock::ChainLockSig>(bestChainLockWithKnownBlock);
         pindex = currentBestChainLockBlockIndex = this->bestChainLockBlockIndex;
 
         if (currentBestChainLockBlockIndex == nullptr) {
@@ -510,51 +366,20 @@ void CChainLocksHandler::EnforceBestChainLock()
     ::g_stats_client->gauge("chainlocks.blockHeight", clsig->getHeight(), 1.0f);
 }
 
-MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
-{
-    if (!isEnabled) {
-        return {};
-    }
-
-    CChainLockSig clsig;
-    {
-        LOCK(cs);
-
-        if (recoveredSig.getId() != lastSignedRequestId || recoveredSig.getMsgHash() != lastSignedMsgHash) {
-            // this is not what we signed, so lets not create a CLSIG for it
-            return {};
-        }
-        if (bestChainLock.getHeight() >= lastSignedHeight) {
-            // already got the same or a better CLSIG through the CLSIG message
-            return {};
-        }
-
-
-        clsig = CChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
-    }
-    return ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
-}
-
-bool CChainLocksHandler::HasChainLock(int nHeight, const uint256& blockHash) const
-{
-    LOCK(cs);
-    return InternalHasChainLock(nHeight, blockHash);
-}
-
-
-VerifyRecSigStatus CChainLocksHandler::VerifyChainLock(const CChainLockSig& clsig) const
+VerifyRecSigStatus CChainLocksHandler::VerifyChainLock(const chainlock::ChainLockSig& clsig) const
 {
     const auto llmqType = Params().GetConsensus().llmqTypeChainLocks;
-    const uint256 nRequestId = ::SerializeHash(std::make_pair(llmq::CLSIG_REQUESTID_PREFIX, clsig.getHeight()));
+    const uint256 nRequestId = ::SerializeHash(std::make_pair(chainlock::CLSIG_REQUESTID_PREFIX, clsig.getHeight()));
 
     return llmq::VerifyRecoveredSig(llmqType, m_chainstate.m_chain, qman, clsig.getHeight(), nRequestId, clsig.getBlockHash(), clsig.getSig());
 }
 
-bool CChainLocksHandler::InternalHasChainLock(int nHeight, const uint256& blockHash) const
+bool CChainLocksHandler::HasChainLock(int nHeight, const uint256& blockHash) const
 {
-    AssertLockHeld(cs);
+    AssertLockNotHeld(cs);
+    LOCK(cs);
 
-    if (!isEnabled) {
+    if (!IsEnabled()) {
         return false;
     }
 
@@ -576,15 +401,10 @@ bool CChainLocksHandler::InternalHasChainLock(int nHeight, const uint256& blockH
 
 bool CChainLocksHandler::HasConflictingChainLock(int nHeight, const uint256& blockHash) const
 {
+    AssertLockNotHeld(cs);
     LOCK(cs);
-    return InternalHasConflictingChainLock(nHeight, blockHash);
-}
 
-bool CChainLocksHandler::InternalHasConflictingChainLock(int nHeight, const uint256& blockHash) const
-{
-    AssertLockHeld(cs);
-
-    if (!isEnabled) {
+    if (!IsEnabled()) {
         return false;
     }
 
@@ -626,23 +446,19 @@ void CChainLocksHandler::Cleanup()
             }
         }
     }
-    // need mempool.cs due to GetTransaction calls
-    LOCK2(::cs_main, mempool.cs);
-    LOCK(cs);
 
-    for (auto it = blockTxs.begin(); it != blockTxs.end(); ) {
-        const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);
-        if (InternalHasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            for (const auto& txid : *it->second) {
+    if (m_signer) {
+        const auto cleanup_txes{m_signer->Cleanup()};
+        LOCK(cs);
+        for (const auto& tx : cleanup_txes) {
+            for (const auto& txid : *tx) {
                 txFirstSeenTime.erase(txid);
             }
-            it = blockTxs.erase(it);
-        } else if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            it = blockTxs.erase(it);
-        } else {
-            ++it;
         }
     }
+
+    LOCK(::cs_main);
+    LOCK2(mempool.cs, cs); // need mempool.cs due to GetTransaction calls
     for (auto it = txFirstSeenTime.begin(); it != txFirstSeenTime.end(); ) {
         uint256 hashBlock;
         if (auto tx = GetTransaction(nullptr, &mempool, it->first, Params().GetConsensus(), hashBlock); !tx) {
@@ -661,10 +477,4 @@ void CChainLocksHandler::Cleanup()
         }
     }
 }
-
-bool AreChainLocksEnabled(const CSporkManager& sporkman)
-{
-    return sporkman.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
-}
-
 } // namespace llmq
diff --git a/src/llmq/chainlocks.h b/src/chainlock/chainlock.h
similarity index 55%
rename from src/llmq/chainlocks.h
rename to src/chainlock/chainlock.h
index c91fa946bc01e..69ba8130ae75b 100644
--- a/src/llmq/chainlocks.h
+++ b/src/chainlock/chainlock.h
@@ -2,19 +2,18 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_LLMQ_CHAINLOCKS_H
-#define BITCOIN_LLMQ_CHAINLOCKS_H
+#ifndef BITCOIN_CHAINLOCK_CHAINLOCK_H
+#define BITCOIN_CHAINLOCK_CHAINLOCK_H
 
-#include <llmq/clsig.h>
+#include <chainlock/clsig.h>
 
-#include <crypto/common.h> // For ReadLE64
-#include <llmq/signing.h>
-#include <net.h> // For NodeId
-#include <net_types.h>
 #include <primitives/transaction.h>
+#include <protocol.h>
 #include <saltedhasher.h>
 #include <sync.h>
 
+#include <chainlock/signing.h>
+
 #include <gsl/pointers.h>
 
 #include <atomic>
@@ -29,55 +28,39 @@ class CScheduler;
 class CSporkManager;
 class CTxMemPool;
 
-namespace llmq
-{
+using NodeId = int64_t;
+
+namespace llmq {
 class CInstantSendManager;
+class CQuorumManager;
 class CSigningManager;
 class CSigSharesManager;
 enum class VerifyRecSigStatus;
 
-class CChainLocksHandler : public CRecoveredSigsListener
+class CChainLocksHandler final : public chainlock::ChainLockSignerParent
 {
-    static constexpr int64_t CLEANUP_INTERVAL = 1000 * 30;
-    static constexpr int64_t CLEANUP_SEEN_TIMEOUT = 24 * 60 * 60 * 1000;
-
-    // how long to wait for islocks until we consider a block with non-islocked TXs to be safe to sign
-    static constexpr int64_t WAIT_FOR_ISLOCK_TIMEOUT = 10 * 60;
-
 private:
     CChainState& m_chainstate;
     CQuorumManager& qman;
-    CSigningManager& sigman;
-    CSigSharesManager& shareman;
     CSporkManager& spork_manager;
     CTxMemPool& mempool;
     const CMasternodeSync& m_mn_sync;
-
-    const bool m_is_masternode;
     std::unique_ptr<CScheduler> scheduler;
     std::unique_ptr<std::thread> scheduler_thread;
+
+    std::unique_ptr<chainlock::ChainLockSigner> m_signer{nullptr};
+
     mutable Mutex cs;
     std::atomic<bool> tryLockChainTipScheduled{false};
     std::atomic<bool> isEnabled{false};
 
     uint256 bestChainLockHash GUARDED_BY(cs);
-    CChainLockSig bestChainLock GUARDED_BY(cs);
+    chainlock::ChainLockSig bestChainLock GUARDED_BY(cs);
 
-    CChainLockSig bestChainLockWithKnownBlock GUARDED_BY(cs);
+    chainlock::ChainLockSig bestChainLockWithKnownBlock GUARDED_BY(cs);
     const CBlockIndex* bestChainLockBlockIndex GUARDED_BY(cs) {nullptr};
     const CBlockIndex* lastNotifyChainLockBlockIndex GUARDED_BY(cs) {nullptr};
 
-    int32_t lastSignedHeight GUARDED_BY(cs) {-1};
-    uint256 lastSignedRequestId GUARDED_BY(cs);
-    uint256 lastSignedMsgHash GUARDED_BY(cs);
-
-    // We keep track of txids from recently received blocks so that we can check if all TXs got islocked
-    struct BlockHasher
-    {
-        size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
-    };
-    using BlockTxs = std::unordered_map<uint256, std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>, BlockHasher>;
-    BlockTxs blockTxs GUARDED_BY(cs);
     std::unordered_map<uint256, int64_t, StaticSaltedHasher> txFirstSeenTime GUARDED_BY(cs);
 
     std::map<uint256, int64_t> seenChainLocks GUARDED_BY(cs);
@@ -94,11 +77,14 @@ class CChainLocksHandler : public CRecoveredSigsListener
     void Stop();
 
     bool AlreadyHave(const CInv& inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    bool GetChainLockByHash(const uint256& hash, CChainLockSig& ret) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    CChainLockSig GetBestChainLock() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    bool GetChainLockByHash(const uint256& hash, chainlock::ChainLockSig& ret) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    chainlock::ChainLockSig GetBestChainLock() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void UpdateTxFirstSeenMap(const std::unordered_set<uint256, StaticSaltedHasher>& tx, const int64_t& time) override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const CChainLockSig& clsig,
-                                                              const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const chainlock::ChainLockSig& clsig,
+                                                              const uint256& hash) override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     void AcceptedBlockHeader(gsl::not_null<const CBlockIndex*> pindexNew) EXCLUSIVE_LOCKS_REQUIRED(!cs);
     void UpdatedBlockTip(const llmq::CInstantSendManager& isman);
@@ -106,28 +92,25 @@ class CChainLocksHandler : public CRecoveredSigsListener
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, gsl::not_null<const CBlockIndex*> pindex) EXCLUSIVE_LOCKS_REQUIRED(!cs);
     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, gsl::not_null<const CBlockIndex*> pindexDisconnected) EXCLUSIVE_LOCKS_REQUIRED(!cs);
     void CheckActiveState() EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    void TrySignChainTip(const llmq::CInstantSendManager& isman) EXCLUSIVE_LOCKS_REQUIRED(!cs);
     void EnforceBestChainLock() EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override
-        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
-    bool HasChainLock(int nHeight, const uint256& blockHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    bool HasConflictingChainLock(int nHeight, const uint256& blockHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    VerifyRecSigStatus VerifyChainLock(const CChainLockSig& clsig) const;
+    bool HasChainLock(int nHeight, const uint256& blockHash) const override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    bool HasConflictingChainLock(int nHeight, const uint256& blockHash) const override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    VerifyRecSigStatus VerifyChainLock(const chainlock::ChainLockSig& clsig) const;
 
-    bool IsTxSafeForMining(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    [[nodiscard]] int32_t GetBestChainLockHeight() const override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    bool IsTxSafeForMining(const uint256& txid) const override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    [[nodiscard]] bool IsEnabled() const override { return isEnabled; }
 
 private:
-    // these require locks to be held already
-    bool InternalHasChainLock(int nHeight, const uint256& blockHash) const EXCLUSIVE_LOCKS_REQUIRED(cs);
-    bool InternalHasConflictingChainLock(int nHeight, const uint256& blockHash) const EXCLUSIVE_LOCKS_REQUIRED(cs);
-
-    BlockTxs::mapped_type GetBlockTxs(const uint256& blockHash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
-
     void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 };
 
 bool AreChainLocksEnabled(const CSporkManager& sporkman);
 } // namespace llmq
 
-#endif // BITCOIN_LLMQ_CHAINLOCKS_H
+#endif // BITCOIN_CHAINLOCK_CHAINLOCK_H
diff --git a/src/chainlock/clsig.cpp b/src/chainlock/clsig.cpp
new file mode 100644
index 0000000000000..163c8bad52715
--- /dev/null
+++ b/src/chainlock/clsig.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2021-2022 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 <chainlock/clsig.h>
+
+#include <tinyformat.h>
+
+namespace chainlock {
+const std::string CLSIG_REQUESTID_PREFIX = "clsig";
+
+ChainLockSig::ChainLockSig() = default;
+ChainLockSig::~ChainLockSig() = default;
+
+ChainLockSig::ChainLockSig(int32_t nHeight, const uint256& blockHash, const CBLSSignature& sig) :
+    nHeight{nHeight},
+    blockHash{blockHash},
+    sig{sig}
+{
+}
+
+std::string ChainLockSig::ToString() const
+{
+    return strprintf("ChainLockSig(nHeight=%d, blockHash=%s)", nHeight, blockHash.ToString());
+}
+} // namespace chainlock
diff --git a/src/chainlock/clsig.h b/src/chainlock/clsig.h
new file mode 100644
index 0000000000000..9efd399c27899
--- /dev/null
+++ b/src/chainlock/clsig.h
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2022 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_CHAINLOCK_CLSIG_H
+#define BITCOIN_CHAINLOCK_CLSIG_H
+
+#include <serialize.h>
+#include <uint256.h>
+
+#include <bls/bls.h>
+
+#include <cstdint>
+
+namespace chainlock {
+extern const std::string CLSIG_REQUESTID_PREFIX;
+
+struct ChainLockSig {
+private:
+    int32_t nHeight{-1};
+    uint256 blockHash;
+    CBLSSignature sig;
+
+public:
+    ChainLockSig();
+    ~ChainLockSig();
+
+    ChainLockSig(int32_t nHeight, const uint256& blockHash, const CBLSSignature& sig);
+
+    [[nodiscard]] int32_t getHeight() const { return nHeight; }
+    [[nodiscard]] const uint256& getBlockHash() const { return blockHash; }
+    [[nodiscard]] const CBLSSignature& getSig() const { return sig; }
+    [[nodiscard]] bool IsNull() const { return nHeight == -1 && blockHash == uint256(); }
+    [[nodiscard]] std::string ToString() const;
+
+    SERIALIZE_METHODS(ChainLockSig, obj)
+    {
+        READWRITE(obj.nHeight, obj.blockHash, obj.sig);
+    }
+};
+} // namespace chainlock
+
+#endif // BITCOIN_CHAINLOCK_CLSIG_H
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
new file mode 100644
index 0000000000000..0ef9aa550dfb2
--- /dev/null
+++ b/src/chainlock/signing.cpp
@@ -0,0 +1,259 @@
+// Copyright (c) 2019-2025 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 <chainlock/signing.h>
+
+#include <node/blockstorage.h>
+#include <validation.h>
+
+#include <chainlock/clsig.h>
+#include <instantsend/instantsend.h>
+#include <masternode/sync.h>
+#include <spork.h>
+
+using node::ReadBlockFromDisk;
+
+namespace chainlock {
+ChainLockSigner::ChainLockSigner(CChainState& chainstate, ChainLockSignerParent& clhandler, llmq::CSigningManager& sigman,
+                                 llmq::CSigSharesManager& shareman, CSporkManager& sporkman,
+                                 const CMasternodeSync& mn_sync) :
+    m_chainstate{chainstate},
+    m_clhandler{clhandler},
+    m_sigman{sigman},
+    m_shareman{shareman},
+    m_sporkman{sporkman},
+    m_mn_sync{mn_sync}
+{
+}
+
+ChainLockSigner::~ChainLockSigner() = default;
+
+void ChainLockSigner::Start()
+{
+    m_sigman.RegisterRecoveredSigsListener(this);
+}
+
+void ChainLockSigner::Stop()
+{
+    m_sigman.UnregisterRecoveredSigsListener(this);
+}
+
+void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
+{
+    if (!m_mn_sync.IsBlockchainSynced()) {
+        return;
+    }
+
+    if (!m_clhandler.IsEnabled()) {
+        return;
+    }
+
+    if (m_sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) != 0) {
+        // ChainLocks signing not enabled
+        return;
+    }
+
+    const CBlockIndex* pindex = WITH_LOCK(::cs_main, return m_chainstate.m_chain.Tip());
+
+    if (pindex->pprev == nullptr) {
+        return;
+    }
+
+    // DIP8 defines a process called "Signing attempts" which should run before the CLSIG is finalized
+    // To simplify the initial implementation, we skip this process and directly try to create a CLSIG
+    // This will fail when multiple blocks compete, but we accept this for the initial implementation.
+    // Later, we'll add the multiple attempts process.
+
+    {
+        LOCK(cs_signer);
+
+        if (pindex->nHeight == lastSignedHeight) {
+            // already signed this one
+            return;
+        }
+    }
+
+    if (m_clhandler.GetBestChainLockHeight() >= pindex->nHeight) {
+        // already got the same CLSIG or a better one
+        return;
+    }
+
+    if (m_clhandler.HasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+        // don't sign if another conflicting CLSIG is already present. EnforceBestChainLock will later enforce
+        // the correct chain.
+        return;
+    }
+
+    LogPrint(BCLog::CHAINLOCKS, "%s -- trying to sign %s, height=%d\n", __func__, pindex->GetBlockHash().ToString(), pindex->nHeight);
+
+    // When the new IX system is activated, we only try to ChainLock blocks which include safe transactions. A TX is
+    // considered safe when it is islocked or at least known since 10 minutes (from mempool or block). These checks are
+    // performed for the tip (which we try to sign) and the previous 5 blocks. If a ChainLocked block is found on the
+    // way down, we consider all TXs to be safe.
+    if (isman.IsInstantSendEnabled() && isman.RejectConflictingBlocks()) {
+        const auto* pindexWalk = pindex;
+        while (pindexWalk != nullptr) {
+            if (pindex->nHeight - pindexWalk->nHeight > 5) {
+                // no need to check further down, 6 confs is safe to assume that TXs below this height won't be
+                // islocked anymore if they aren't already
+                LogPrint(BCLog::CHAINLOCKS, "%s -- tip and previous 5 blocks all safe\n", __func__);
+                break;
+            }
+            if (m_clhandler.HasChainLock(pindexWalk->nHeight, pindexWalk->GetBlockHash())) {
+                // we don't care about islocks for TXs that are ChainLocked already
+                LogPrint(BCLog::CHAINLOCKS, "%s -- chainlock at height %d\n", __func__, pindexWalk->nHeight);
+                break;
+            }
+
+            auto txids = GetBlockTxs(pindexWalk->GetBlockHash());
+            if (!txids) {
+                pindexWalk = pindexWalk->pprev;
+                continue;
+            }
+
+            for (const auto& txid : *txids) {
+                if (!m_clhandler.IsTxSafeForMining(txid) && !isman.IsLocked(txid)) {
+                    LogPrint(BCLog::CHAINLOCKS, "%s -- not signing block %s due to TX %s not being islocked and not old enough.\n", __func__,
+                              pindexWalk->GetBlockHash().ToString(), txid.ToString());
+                    return;
+                }
+            }
+
+            pindexWalk = pindexWalk->pprev;
+        }
+    }
+
+    uint256 requestId = ::SerializeHash(std::make_pair(CLSIG_REQUESTID_PREFIX, pindex->nHeight));
+    uint256 msgHash = pindex->GetBlockHash();
+
+    if (m_clhandler.GetBestChainLockHeight() >= pindex->nHeight) {
+        // might have happened while we didn't hold cs
+        return;
+    }
+    {
+        LOCK(cs_signer);
+        lastSignedHeight = pindex->nHeight;
+        lastSignedRequestId = requestId;
+        lastSignedMsgHash = msgHash;
+    }
+
+    m_sigman.AsyncSignIfMember(Params().GetConsensus().llmqTypeChainLocks, m_shareman, requestId, msgHash);
+}
+
+void ChainLockSigner::EraseFromBlockHashTxidMap(const uint256& hash)
+{
+    AssertLockNotHeld(cs_signer);
+    LOCK(cs_signer);
+    blockTxs.erase(hash);
+}
+
+void ChainLockSigner::UpdateBlockHashTxidMap(const uint256& hash, const std::vector<CTransactionRef>& vtx)
+{
+    AssertLockNotHeld(cs_signer);
+    LOCK(cs_signer);
+    auto it = blockTxs.find(hash);
+    if (it == blockTxs.end()) {
+        // We must create this entry even if there are no lockable transactions in the block, so that TrySignChainTip
+        // later knows about this block
+        it = blockTxs.emplace(hash, std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>()).first;
+    }
+    auto& txids = *it->second;
+    for (const auto& tx : vtx) {
+        if (!tx->IsCoinBase() && !tx->vin.empty()) {
+            txids.emplace(tx->GetHash());
+        }
+    }
+}
+
+ChainLockSigner::BlockTxs::mapped_type ChainLockSigner::GetBlockTxs(const uint256& blockHash)
+{
+    AssertLockNotHeld(cs_signer);
+    AssertLockNotHeld(::cs_main);
+
+    ChainLockSigner::BlockTxs::mapped_type ret;
+
+    {
+        LOCK(cs_signer);
+        auto it = blockTxs.find(blockHash);
+        if (it != blockTxs.end()) {
+            ret = it->second;
+        }
+    }
+    if (!ret) {
+        // This should only happen when freshly started.
+        // If running for some time, SyncTransaction should have been called before which fills blockTxs.
+        LogPrint(BCLog::CHAINLOCKS, "%s -- blockTxs for %s not found. Trying ReadBlockFromDisk\n", __func__,
+                 blockHash.ToString());
+
+        uint32_t blockTime;
+        {
+            LOCK(::cs_main);
+            const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(blockHash);
+            CBlock block;
+            if (!ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+                return nullptr;
+            }
+
+            ret = std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>();
+            for (const auto& tx : block.vtx) {
+                if (tx->IsCoinBase() || tx->vin.empty()) {
+                    continue;
+                }
+                ret->emplace(tx->GetHash());
+            }
+
+            blockTime = block.nTime;
+        }
+        {
+            LOCK(cs_signer);
+            blockTxs.emplace(blockHash, ret);
+        }
+        m_clhandler.UpdateTxFirstSeenMap(*ret, blockTime);
+    }
+    return ret;
+}
+
+MessageProcessingResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
+{
+    if (!m_clhandler.IsEnabled()) {
+        return {};
+    }
+
+    ChainLockSig clsig;
+    {
+        LOCK(cs_signer);
+
+        if (recoveredSig.getId() != lastSignedRequestId || recoveredSig.getMsgHash() != lastSignedMsgHash) {
+            // this is not what we signed, so lets not create a CLSIG for it
+            return {};
+        }
+        if (m_clhandler.GetBestChainLockHeight() >= lastSignedHeight) {
+            // already got the same or a better CLSIG through the CLSIG message
+            return {};
+        }
+
+        clsig = ChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
+    }
+    return m_clhandler.ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
+}
+
+std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> ChainLockSigner::Cleanup()
+{
+    AssertLockNotHeld(cs_signer);
+    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> removed;
+    LOCK2(::cs_main, cs_signer);
+    for (auto it = blockTxs.begin(); it != blockTxs.end(); ) {
+        const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);
+        if (m_clhandler.HasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            removed.push_back(it->second);
+            it = blockTxs.erase(it);
+        } else if (m_clhandler.HasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            it = blockTxs.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    return removed;
+}
+} // namespace chainlock
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
new file mode 100644
index 0000000000000..a07df18265cd8
--- /dev/null
+++ b/src/chainlock/signing.h
@@ -0,0 +1,89 @@
+// Copyright (c) 2019-2025 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_CHAINLOCK_SIGNING_H
+#define BITCOIN_CHAINLOCK_SIGNING_H
+
+#include <chainlock/clsig.h>
+#include <llmq/signing.h>
+
+class CMasternodeSync;
+class CSporkManager;
+struct MessageProcessingResult;
+namespace llmq {
+class CChainLocksHandler;
+class CInstantSendManager;
+class CRecoveredSig;
+class CSigningManager;
+class CSigSharesManager;
+} // namespace llmq
+
+namespace chainlock {
+class ChainLockSignerParent
+{
+public:
+    virtual ~ChainLockSignerParent() = default;
+
+    virtual int32_t GetBestChainLockHeight() const = 0;
+    virtual bool HasChainLock(int nHeight, const uint256& blockHash) const = 0;
+    virtual bool HasConflictingChainLock(int nHeight, const uint256& blockHash) const = 0;
+    virtual bool IsEnabled() const = 0;
+    virtual bool IsTxSafeForMining(const uint256& txid) const = 0;
+    virtual MessageProcessingResult ProcessNewChainLock(NodeId from, const ChainLockSig& clsig, const uint256& hash) = 0;
+    virtual void UpdateTxFirstSeenMap(const std::unordered_set<uint256, StaticSaltedHasher>& tx, const int64_t& time) = 0;
+};
+
+class ChainLockSigner final : public llmq::CRecoveredSigsListener
+{
+private:
+    CChainState& m_chainstate;
+    ChainLockSignerParent& m_clhandler;
+    llmq::CSigningManager& m_sigman;
+    llmq::CSigSharesManager& m_shareman;
+    CSporkManager& m_sporkman;
+    const CMasternodeSync& m_mn_sync;
+
+private:
+    // We keep track of txids from recently received blocks so that we can check if all TXs got islocked
+    struct BlockHasher {
+        size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
+    };
+    using BlockTxs = std::unordered_map<uint256, std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>, BlockHasher>;
+
+private:
+    mutable Mutex cs_signer;
+
+    BlockTxs blockTxs GUARDED_BY(cs_signer);
+    int32_t lastSignedHeight GUARDED_BY(cs_signer){-1};
+    uint256 lastSignedRequestId GUARDED_BY(cs_signer);
+    uint256 lastSignedMsgHash GUARDED_BY(cs_signer);
+
+public:
+    explicit ChainLockSigner(CChainState& chainstate, ChainLockSignerParent& clhandler, llmq::CSigningManager& sigman,
+                             llmq::CSigSharesManager& shareman, CSporkManager& sporkman, const CMasternodeSync& mn_sync);
+    ~ChainLockSigner();
+
+    void Start();
+    void Stop();
+
+    void EraseFromBlockHashTxidMap(const uint256& hash)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+    void UpdateBlockHashTxidMap(const uint256& hash, const std::vector<CTransactionRef>& vtx)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+
+    void TrySignChainTip(const llmq::CInstantSendManager& isman)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+    [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+
+    [[nodiscard]] std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> Cleanup()
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+
+private:
+    [[nodiscard]] BlockTxs::mapped_type GetBlockTxs(const uint256& blockHash)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
+};
+} // namespace chainlock
+
+#endif // BITCOIN_CHAINLOCK_SIGNING_H
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 641a1e7c02d31..07ddb2018090f 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -4,20 +4,21 @@
 
 #include <coinjoin/coinjoin.h>
 
-#include <bls/bls.h>
 #include <chain.h>
 #include <chainparams.h>
-#include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
-#include <masternode/node.h>
-#include <masternode/sync.h>
 #include <txmempool.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
-
 #include <tinyformat.h>
+
+#include <bls/bls.h>
+#include <chainlock/chainlock.h>
+#include <instantsend/instantsend.h>
+#include <masternode/node.h>
+#include <masternode/sync.h>
+
 #include <string>
 
 constexpr static CAmount DEFAULT_MAX_RAW_TX_FEE{COIN / 10};
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index 184689904ca47..1b6d80b687375 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -12,10 +12,10 @@
 #include <masternode/sync.h>
 #include <validation.h>
 
+#include <chainlock/chainlock.h>
 #include <evo/deterministicmns.h>
 #include <evo/mnauth.h>
 #include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/ehf_signals.h>
@@ -143,7 +143,8 @@ void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDet
     }
 }
 
-void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
+void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex,
+                                               const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
     assert(m_cj_ctx && m_llmq_ctx);
 
diff --git a/src/dsnotificationinterface.h b/src/dsnotificationinterface.h
index 92ee04aac1d36..6ca8634e2cc1c 100644
--- a/src/dsnotificationinterface.h
+++ b/src/dsnotificationinterface.h
@@ -46,7 +46,7 @@ class CDSNotificationInterface : public CValidationInterface
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) override;
     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected) override;
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) override;
-    void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override;
+    void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 
 private:
     CConnman& m_connman;
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
index bda004ab14b30..d4661d71b7246 100644
--- a/src/evo/chainhelper.cpp
+++ b/src/evo/chainhelper.cpp
@@ -5,10 +5,11 @@
 #include <evo/chainhelper.h>
 
 #include <chainparams.h>
+
+#include <chainlock/chainlock.h>
 #include <evo/specialtxman.h>
 #include <instantsend/instantsend.h>
 #include <instantsend/lock.h>
-#include <llmq/chainlocks.h>
 #include <masternode/payments.h>
 
 CChainstateHelper::CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman,
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index f0141922f4609..80fc0cabbb97c 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -8,6 +8,13 @@
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
+#include <hash.h>
+#include <primitives/block.h>
+#include <util/irange.h>
+#include <validation.h>
+
+#include <chainlock/chainlock.h>
+#include <chainlock/clsig.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 #include <evo/creditpool.h>
@@ -15,14 +22,9 @@
 #include <evo/mnhftx.h>
 #include <evo/simplifiedmns.h>
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
-#include <llmq/clsig.h>
 #include <llmq/commitment.h>
 #include <llmq/quorums.h>
 #include <llmq/utils.h>
-#include <primitives/block.h>
-#include <util/irange.h>
-#include <validation.h>
 
 static bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex,
                                    const llmq::CChainLocksHandler& chainlock_handler, BlockValidationState& state)
@@ -76,7 +78,7 @@ static bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex,
         }
         uint256 curBlockCoinbaseCLBlockHash = pindex->GetAncestor(curBlockCoinbaseCLHeight)->GetBlockHash();
         if (chainlock_handler.VerifyChainLock(
-                llmq::CChainLockSig(curBlockCoinbaseCLHeight, curBlockCoinbaseCLBlockHash, cbTx.bestCLSignature)) !=
+                chainlock::ChainLockSig(curBlockCoinbaseCLHeight, curBlockCoinbaseCLBlockHash, cbTx.bestCLSignature)) !=
             llmq::VerifyRecSigStatus::Valid) {
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cbtx-invalid-clsig");
         }
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
index 4a228bc18537c..ea182b3dfb604 100644
--- a/src/instantsend/instantsend.cpp
+++ b/src/instantsend/instantsend.cpp
@@ -8,18 +8,18 @@
 #include <consensus/validation.h>
 #include <net_processing.h>
 #include <node/blockstorage.h>
-#include <stats/client.h>
 #include <txmempool.h>
 #include <util/thread.h>
 #include <validation.h>
 
 #include <bls/bls_batchverifier.h>
+#include <chainlock/chainlock.h>
 #include <instantsend/signing.h>
-#include <llmq/chainlocks.h>
 #include <llmq/commitment.h>
 #include <llmq/quorums.h>
 #include <masternode/sync.h>
 #include <spork.h>
+#include <stats/client.h>
 
 #include <cxxtimer.hpp>
 
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 7fb3c7d8ecffe..46ea06702de64 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -11,7 +11,7 @@
 #include <util/irange.h>
 #include <validation.h>
 
-#include <llmq/chainlocks.h>
+#include <chainlock/chainlock.h>
 #include <llmq/quorums.h>
 #include <masternode/sync.h>
 #include <spork.h>
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index 5dc214fa54a72..19ebf9d6f3bf2 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -31,12 +31,12 @@ enum class MemPoolRemovalReason;
 struct bilingual_str;
 struct CBlockLocator;
 struct FeeCalculation;
+namespace chainlock {
+struct ChainLockSig;
+} // namespace chainlock
 namespace instantsend {
 struct InstantSendLock;
 } // namespace instantsend
-namespace llmq {
-class CChainLockSig;
-} // namespace llmq
 namespace node {
 struct NodeContext;
 } // namespace node
@@ -267,7 +267,7 @@ class Chain
         virtual void blockDisconnected(const CBlock& block, int height) {}
         virtual void updatedBlockTip() {}
         virtual void chainStateFlushed(const CBlockLocator& locator) {}
-        virtual void notifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const llmq::CChainLockSig>& clsig) {}
+        virtual void notifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) {}
         virtual void notifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const instantsend::InstantSendLock>& islock) {}
     };
 
diff --git a/src/llmq/clsig.cpp b/src/llmq/clsig.cpp
deleted file mode 100644
index 686b2d15bfcfa..0000000000000
--- a/src/llmq/clsig.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2021-2022 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 <llmq/clsig.h>
-#include <tinyformat.h>
-
-namespace llmq {
-    const std::string CLSIG_REQUESTID_PREFIX = "clsig";
-
-    std::string CChainLockSig::ToString() const {
-        return strprintf("CChainLockSig(nHeight=%d, blockHash=%s)", nHeight, blockHash.ToString());
-    }
-    int32_t CChainLockSig::getHeight() const {
-        return nHeight;
-    }
-    const uint256& CChainLockSig::getBlockHash() const {
-        return blockHash;
-    }
-    const CBLSSignature& CChainLockSig::getSig() const {
-        return sig;
-    }
-    bool CChainLockSig::IsNull() const
-    {
-        return nHeight == -1 && blockHash == uint256();
-    }
-}
diff --git a/src/llmq/clsig.h b/src/llmq/clsig.h
deleted file mode 100644
index f8e0ea9629ac2..0000000000000
--- a/src/llmq/clsig.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2019-2022 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_LLMQ_CLSIG_H
-#define BITCOIN_LLMQ_CLSIG_H
-
-#include <bls/bls.h>
-#include <serialize.h>
-#include <uint256.h>
-
-namespace llmq
-{
-
-extern const std::string CLSIG_REQUESTID_PREFIX;
-
-class CChainLockSig
-{
-private:
-    int32_t nHeight{-1};
-    uint256 blockHash;
-    CBLSSignature sig;
-
-public:
-    CChainLockSig(int32_t nHeight, const uint256& blockHash, const CBLSSignature& sig) :
-        nHeight(nHeight),
-        blockHash(blockHash),
-        sig(sig)
-    {}
-    CChainLockSig() = default;
-
-
-    [[nodiscard]] int32_t getHeight() const;
-    [[nodiscard]] const uint256& getBlockHash() const;
-    [[nodiscard]] const CBLSSignature& getSig() const;
-    [[nodiscard]] bool IsNull() const;
-    [[nodiscard]] std::string ToString() const;
-
-    SERIALIZE_METHODS(CChainLockSig, obj)
-    {
-        READWRITE(obj.nHeight, obj.blockHash, obj.sig);
-    }
-};
-} // namespace llmq
-
-#endif // BITCOIN_LLMQ_CLSIG_H
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index 87ed6f4709fe9..e2a60f21420b3 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -5,9 +5,9 @@
 #include <llmq/context.h>
 
 #include <bls/bls_worker.h>
+#include <chainlock/chainlock.h>
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/ehf_signals.h>
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 1d634907c5bc9..eb57d9ee1b5ab 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -59,13 +59,13 @@
 #include <coinjoin/context.h>
 #include <coinjoin/server.h>
 
+#include <chainlock/chainlock.h>
 #include <evo/deterministicmns.h>
 #include <evo/mnauth.h>
 #include <evo/smldiff.h>
 #include <instantsend/lock.h>
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
 #include <llmq/dkgsession.h>
@@ -2858,7 +2858,7 @@ void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic
         }
 
         if (!push && (inv.type == MSG_CLSIG)) {
-            llmq::CChainLockSig o;
+            chainlock::ChainLockSig o;
             if (m_llmq_ctx->clhandler->GetChainLockByHash(inv.hash, o)) {
                 m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::CLSIG, o));
                 push = true;
@@ -5282,7 +5282,7 @@ void PeerManagerImpl::ProcessMessage(
 
         if (msg_type == NetMsgType::CLSIG) {
             if (llmq::AreChainLocksEnabled(m_sporkman)) {
-                llmq::CChainLockSig clsig;
+                chainlock::ChainLockSig clsig;
                 vRecv >> clsig;
                 const uint256& hash = ::SerializeHash(clsig);
                 WITH_LOCK(::cs_main, EraseObjectRequest(pfrom.GetId(), CInv{MSG_CLSIG, hash}));
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 493c8606c86c6..3f08db154699c 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -7,6 +7,7 @@
 #include <addrdb.h>
 #include <banman.h>
 #include <chain.h>
+#include <chainlock/chainlock.h>
 #include <chainparams.h>
 #include <coinjoin/common.h>
 #include <deploymentstatus.h>
@@ -21,7 +22,6 @@
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
 #include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <mapport.h>
 #include <masternode/sync.h>
@@ -653,7 +653,7 @@ class NotificationsProxy : public CValidationInterface
         m_notifications->updatedBlockTip();
     }
     void ChainStateFlushed(const CBlockLocator& locator) override { m_notifications->chainStateFlushed(locator); }
-    void NotifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override
+    void NotifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override
     {
         m_notifications->notifyChainLock(pindexChainLock, clsig);
     }
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 7409093904b06..8b2626570da11 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -24,6 +24,7 @@
 #include <util/system.h>
 #include <validation.h>
 
+#include <chainlock/chainlock.h>
 #include <evo/specialtx.h>
 #include <evo/cbtx.h>
 #include <evo/chainhelper.h>
@@ -35,7 +36,6 @@
 #include <governance/governance.h>
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <llmq/options.h>
 #include <llmq/snapshot.h>
@@ -127,7 +127,7 @@ static bool CalcCbTxBestChainlock(const llmq::CChainLocksHandler& chainlock_hand
     auto best_clsig = chainlock_handler.GetBestChainLock();
     if (best_clsig.getHeight() < Params().GetConsensus().DeploymentHeight(Consensus::DEPLOYMENT_V19)) {
         // We don't want legacy BLS ChainLocks in CbTx (can happen on regtest/devenets)
-        best_clsig = llmq::CChainLockSig{};
+        best_clsig = chainlock::ChainLockSig{};
     }
     if (best_clsig.getHeight() == pindexPrev->nHeight) {
         // Our best CL is the newest one possible
diff --git a/src/rest.cpp b/src/rest.cpp
index 790b55af47acc..9771a2f62327f 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -6,13 +6,13 @@
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <chainlock/chainlock.h>
 #include <context.h>
 #include <core_io.h>
 #include <httpserver.h>
 #include <index/blockfilterindex.h>
 #include <index/txindex.h>
 #include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <node/blockstorage.h>
 #include <node/context.h>
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index ae6ca2b23ea84..b9fb546903a49 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -20,7 +20,6 @@
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
-#include <llmq/context.h>
 #include <logging/timer.h>
 #include <node/blockstorage.h>
 #include <node/coinstats.h>
@@ -49,13 +48,14 @@
 #include <versionbits.h>
 #include <warnings.h>
 
+#include <chainlock/chainlock.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
 #include <evo/specialtx.h>
 #include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
+#include <llmq/context.h>
 
 #include <stdint.h>
 
@@ -268,7 +268,7 @@ static RPCHelpMan getbestchainlock()
     const NodeContext& node = EnsureAnyNodeContext(request.context);
 
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
-    const llmq::CChainLockSig clsig = llmq_ctx.clhandler->GetBestChainLock();
+    const chainlock::ChainLockSig clsig = llmq_ctx.clhandler->GetBestChainLock();
     if (clsig.IsNull()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to find any ChainLock");
     }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index ec3723e1d9bd1..d3d28d516c005 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -5,6 +5,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
+#include <chainlock/chainlock.h>
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
@@ -17,7 +18,6 @@
 #include <key_io.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/context.h>
-#include <llmq/chainlocks.h>
 #include <evo/evodb.h>
 #include <net.h>
 #include <node/context.h>
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index f0854b3371745..c25cb717dfb2a 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -13,11 +13,9 @@
 #include <util/check.h>
 #include <validation.h>
 
-#include <masternode/node.h>
+#include <chainlock/chainlock.h>
 #include <evo/deterministicmns.h>
-
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
 #include <llmq/debug.h>
@@ -28,6 +26,7 @@
 #include <llmq/signing_shares.h>
 #include <llmq/snapshot.h>
 #include <llmq/utils.h>
+#include <masternode/node.h>
 
 #include <iomanip>
 #include <optional>
@@ -1021,7 +1020,8 @@ static RPCHelpMan verifychainlock()
     }
 
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
-    return llmq_ctx.clhandler->VerifyChainLock(llmq::CChainLockSig(nBlockHeight, nBlockHash, sig)) == llmq::VerifyRecSigStatus::Valid;
+    return llmq_ctx.clhandler->VerifyChainLock(chainlock::ChainLockSig(nBlockHeight, nBlockHash, sig)) ==
+           llmq::VerifyRecSigStatus::Valid;
 },
     };
 }
@@ -1132,7 +1132,7 @@ static RPCHelpMan submitchainlock()
     }
 
 
-    const auto clsig{llmq::CChainLockSig(nBlockHeight, nBlockHash, sig)};
+    const auto clsig{chainlock::ChainLockSig(nBlockHeight, nBlockHash, sig)};
     const llmq::VerifyRecSigStatus ret{llmq_ctx.clhandler->VerifyChainLock(clsig)};
     if (ret == llmq::VerifyRecSigStatus::NoQuorum) {
         LOCK(cs_main);
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 27aa042a927f2..12b4ef5709147 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -48,11 +48,11 @@
 #include <validationinterface.h>
 #include <util/irange.h>
 
+#include <chainlock/chainlock.h>
 #include <evo/cbtx.h>
 #include <evo/specialtx.h>
 #include <instantsend/lock.h>
 #include <instantsend/instantsend.h>
-#include <llmq/chainlocks.h>
 #include <llmq/context.h>
 
 #include <numeric>
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
index 5b458ba0a5414..73f255cbf841b 100644
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -24,7 +24,6 @@
 #include <version.h>
 
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/quorums.h>
 #include <llmq/signing.h>
diff --git a/src/test/llmq_chainlock_tests.cpp b/src/test/llmq_chainlock_tests.cpp
index 0f364b1e40469..69857f193b8b7 100644
--- a/src/test/llmq_chainlock_tests.cpp
+++ b/src/test/llmq_chainlock_tests.cpp
@@ -5,12 +5,14 @@
 #include <test/util/llmq_tests.h>
 #include <test/util/setup_common.h>
 
-#include <llmq/clsig.h>
 #include <streams.h>
 #include <util/strencodings.h>
 
+#include <chainlock/clsig.h>
+
 #include <boost/test/unit_test.hpp>
 
+using chainlock::ChainLockSig;
 using namespace llmq;
 using namespace llmq::testutils;
 
@@ -19,7 +21,7 @@ BOOST_FIXTURE_TEST_SUITE(llmq_chainlock_tests, BasicTestingSetup)
 BOOST_AUTO_TEST_CASE(chainlock_construction_test)
 {
     // Test default constructor
-    CChainLockSig clsig1;
+    ChainLockSig clsig1;
     BOOST_CHECK(clsig1.IsNull());
     BOOST_CHECK_EQUAL(clsig1.getHeight(), -1);
     BOOST_CHECK(clsig1.getBlockHash().IsNull());
@@ -30,7 +32,7 @@ BOOST_AUTO_TEST_CASE(chainlock_construction_test)
     uint256 blockHash = GetTestBlockHash(1);
     CBLSSignature sig = CreateRandomBLSSignature();
 
-    CChainLockSig clsig2(height, blockHash, sig);
+    ChainLockSig clsig2(height, blockHash, sig);
     BOOST_CHECK(!clsig2.IsNull());
     BOOST_CHECK_EQUAL(clsig2.getHeight(), height);
     BOOST_CHECK(clsig2.getBlockHash() == blockHash);
@@ -39,13 +41,13 @@ BOOST_AUTO_TEST_CASE(chainlock_construction_test)
 
 BOOST_AUTO_TEST_CASE(chainlock_null_test)
 {
-    CChainLockSig clsig;
+    ChainLockSig clsig;
 
     // Default constructed should be null
     BOOST_CHECK(clsig.IsNull());
 
     // With height set but null hash, should not be null
-    clsig = CChainLockSig(100, uint256(), CBLSSignature());
+    clsig = ChainLockSig(100, uint256(), CBLSSignature());
     BOOST_CHECK(!clsig.IsNull());
 
     // With valid data should not be null
@@ -56,13 +58,13 @@ BOOST_AUTO_TEST_CASE(chainlock_null_test)
 BOOST_AUTO_TEST_CASE(chainlock_serialization_test)
 {
     // Test with valid chainlock
-    CChainLockSig clsig = CreateChainLock(67890, GetTestBlockHash(42));
+    ChainLockSig clsig = CreateChainLock(67890, GetTestBlockHash(42));
 
     // Test serialization preserves all fields
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << clsig;
 
-    CChainLockSig deserialized;
+    ChainLockSig deserialized;
     ss >> deserialized;
 
     BOOST_CHECK_EQUAL(clsig.getHeight(), deserialized.getHeight());
@@ -74,14 +76,14 @@ BOOST_AUTO_TEST_CASE(chainlock_serialization_test)
 BOOST_AUTO_TEST_CASE(chainlock_tostring_test)
 {
     // Test null chainlock
-    CChainLockSig nullClsig;
+    ChainLockSig nullClsig;
     std::string nullStr = nullClsig.ToString();
     BOOST_CHECK(!nullStr.empty());
 
     // Test valid chainlock
     int32_t height = 123456;
     uint256 blockHash = GetTestBlockHash(789);
-    CChainLockSig clsig = CreateChainLock(height, blockHash);
+    ChainLockSig clsig = CreateChainLock(height, blockHash);
 
     std::string str = clsig.ToString();
     BOOST_CHECK(!str.empty());
@@ -94,23 +96,23 @@ BOOST_AUTO_TEST_CASE(chainlock_tostring_test)
 BOOST_AUTO_TEST_CASE(chainlock_edge_cases_test)
 {
     // Test with edge case heights
-    CChainLockSig clsig1 = CreateChainLock(0, GetTestBlockHash(1));
+    ChainLockSig clsig1 = CreateChainLock(0, GetTestBlockHash(1));
     BOOST_CHECK_EQUAL(clsig1.getHeight(), 0);
     BOOST_CHECK(!clsig1.IsNull());
 
-    CChainLockSig clsig2 = CreateChainLock(std::numeric_limits<int32_t>::max(), GetTestBlockHash(2));
+    ChainLockSig clsig2 = CreateChainLock(std::numeric_limits<int32_t>::max(), GetTestBlockHash(2));
     BOOST_CHECK_EQUAL(clsig2.getHeight(), std::numeric_limits<int32_t>::max());
 
     // Test serialization with extreme values
     CDataStream ss1(SER_NETWORK, PROTOCOL_VERSION);
     ss1 << clsig1;
-    CChainLockSig clsig1_deserialized;
+    ChainLockSig clsig1_deserialized;
     ss1 >> clsig1_deserialized;
     BOOST_CHECK_EQUAL(clsig1.getHeight(), clsig1_deserialized.getHeight());
 
     CDataStream ss2(SER_NETWORK, PROTOCOL_VERSION);
     ss2 << clsig2;
-    CChainLockSig clsig2_deserialized;
+    ChainLockSig clsig2_deserialized;
     ss2 >> clsig2_deserialized;
     BOOST_CHECK_EQUAL(clsig2.getHeight(), clsig2_deserialized.getHeight());
 }
@@ -122,8 +124,8 @@ BOOST_AUTO_TEST_CASE(chainlock_comparison_test)
     uint256 blockHash = GetTestBlockHash(10);
     CBLSSignature sig = CreateRandomBLSSignature();
 
-    CChainLockSig clsig1(height, blockHash, sig);
-    CChainLockSig clsig2(height, blockHash, sig);
+    ChainLockSig clsig1(height, blockHash, sig);
+    ChainLockSig clsig2(height, blockHash, sig);
 
     // Verify getters return same values
     BOOST_CHECK_EQUAL(clsig1.getHeight(), clsig2.getHeight());
@@ -131,17 +133,17 @@ BOOST_AUTO_TEST_CASE(chainlock_comparison_test)
     BOOST_CHECK(clsig1.getSig() == clsig2.getSig());
 
     // Different chainlocks
-    CChainLockSig clsig3(height + 1, blockHash, sig);
+    ChainLockSig clsig3(height + 1, blockHash, sig);
     BOOST_CHECK(clsig1.getHeight() != clsig3.getHeight());
 
-    CChainLockSig clsig4(height, GetTestBlockHash(11), sig);
+    ChainLockSig clsig4(height, GetTestBlockHash(11), sig);
     BOOST_CHECK(clsig1.getBlockHash() != clsig4.getBlockHash());
 }
 
 BOOST_AUTO_TEST_CASE(chainlock_malformed_data_test)
 {
     // Test deserialization of truncated data
-    CChainLockSig clsig = CreateChainLock(1000, GetTestBlockHash(5));
+    ChainLockSig clsig = CreateChainLock(1000, GetTestBlockHash(5));
 
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << clsig;
@@ -152,7 +154,7 @@ BOOST_AUTO_TEST_CASE(chainlock_malformed_data_test)
         CDataStream truncated(std::vector<unsigned char>(data.begin(), data.begin() + truncateAt), SER_NETWORK,
                               PROTOCOL_VERSION);
 
-        CChainLockSig deserialized;
+        ChainLockSig deserialized;
         try {
             truncated >> deserialized;
             // If no exception, verify it's either complete or default
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index bcd497bb320b9..e7f6bb7a5fc1f 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -7,16 +7,10 @@
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
-#include <evo/evodb.h>
-#include <governance/governance.h>
-#include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
-#include <llmq/context.h>
 #include <node/miner.h>
 #include <policy/policy.h>
 #include <pow.h>
 #include <script/standard.h>
-#include <spork.h>
 #include <uint256.h>
 #include <util/strencodings.h>
 #include <util/system.h>
@@ -24,6 +18,13 @@
 #include <validation.h>
 #include <versionbits.h>
 
+#include <evo/evodb.h>
+#include <governance/governance.h>
+#include <instantsend/instantsend.h>
+#include <llmq/blockprocessor.h>
+#include <llmq/context.h>
+#include <spork.h>
+
 #include <test/util/setup_common.h>
 
 #include <memory>
diff --git a/src/test/util/llmq_tests.h b/src/test/util/llmq_tests.h
index baa5d14bd3f58..7859f28679ece 100644
--- a/src/test/util/llmq_tests.h
+++ b/src/test/util/llmq_tests.h
@@ -5,19 +5,21 @@
 #ifndef BITCOIN_TEST_UTIL_LLMQ_TESTS_H
 #define BITCOIN_TEST_UTIL_LLMQ_TESTS_H
 
+#include <test/util/setup_common.h>
+
 #include <arith_uint256.h>
 #include <bls/bls.h>
 #include <consensus/params.h>
-#include <llmq/clsig.h>
-#include <llmq/commitment.h>
-#include <llmq/params.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <serialize.h>
 #include <streams.h>
-#include <test/util/setup_common.h>
 #include <uint256.h>
 
+#include <chainlock/clsig.h>
+#include <llmq/commitment.h>
+#include <llmq/params.h>
+
 #include <vector>
 
 namespace llmq {
@@ -64,10 +66,10 @@ inline CFinalCommitment CreateValidCommitment(const Consensus::LLMQParams& param
     return commitment;
 }
 
-inline CChainLockSig CreateChainLock(int32_t height, const uint256& blockHash)
+inline chainlock::ChainLockSig CreateChainLock(int32_t height, const uint256& blockHash)
 {
     CBLSSignature sig = CreateRandomBLSSignature();
-    return CChainLockSig(height, blockHash, sig);
+    return chainlock::ChainLockSig(height, blockHash, sig);
 }
 
 // Helper to create bit vectors with specific patterns
diff --git a/src/validation.cpp b/src/validation.cpp
index 29ce4c2184ebd..e97254b8a7e85 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -50,12 +50,12 @@
 #include <validationinterface.h>
 #include <warnings.h>
 
+#include <chainlock/chainlock.h>
 #include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
-#include <llmq/chainlocks.h>
 #include <masternode/payments.h>
 #include <stats/client.h>
 
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
index e3594469a0c95..c0acb1a4ee4d4 100644
--- a/src/validationinterface.cpp
+++ b/src/validationinterface.cpp
@@ -277,7 +277,7 @@ void CMainSignals::NotifyTransactionLock(const CTransactionRef &tx, const std::s
                           tx->GetHash().ToString());
 }
 
-void CMainSignals::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig, const std::string& id) {
+void CMainSignals::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig, const std::string& id) {
     auto event = [pindex, clsig, this] {
         m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyChainLock(pindex, clsig); });
     };
diff --git a/src/validationinterface.h b/src/validationinterface.h
index 5cb6bb96edcb0..dc20388ddfc62 100644
--- a/src/validationinterface.h
+++ b/src/validationinterface.h
@@ -25,6 +25,9 @@ class CDeterministicMNListDiff;
 class uint256;
 class CScheduler;
 enum class MemPoolRemovalReason;
+namespace chainlock {
+struct ChainLockSig;
+} // namespace chainlock
 namespace Governance {
 class Object;
 } // namespace Governance
@@ -32,7 +35,6 @@ namespace instantsend {
 struct InstantSendLock;
 } // namespace instantsend
 namespace llmq {
-class CChainLockSig;
 class CRecoveredSig;
 } // namespace llmq
 
@@ -164,7 +166,7 @@ class CValidationInterface {
      */
     virtual void BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex *pindex) {}
     virtual void NotifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const instantsend::InstantSendLock>& islock) {}
-    virtual void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) {}
+    virtual void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) {}
     virtual void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote) {}
     virtual void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object) {}
     virtual void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) {}
@@ -232,7 +234,7 @@ class CMainSignals {
     void BlockConnected(const std::shared_ptr<const CBlock> &, const CBlockIndex *pindex);
     void BlockDisconnected(const std::shared_ptr<const CBlock> &, const CBlockIndex* pindex);
     void NotifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const instantsend::InstantSendLock>& islock);
-    void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig, const std::string& id);
+    void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig, const std::string& id);
     void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote, const std::string& id);
     void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object, const std::string& id);
     void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef &currentTx, const CTransactionRef &previousTx);
diff --git a/src/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index 9a3cc0c288e8c..d82d043424694 100644
--- a/src/wallet/rpc/wallet.cpp
+++ b/src/wallet/rpc/wallet.cpp
@@ -28,7 +28,6 @@
 
 #include <coinjoin/client.h>
 #include <coinjoin/options.h>
-#include <llmq/chainlocks.h>
 
 #include <optional>
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index dc6be0d2d13e7..698f7ee417994 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -3465,7 +3465,7 @@ void CWallet::notifyTransactionLock(const CTransactionRef &tx, const std::shared
     }
 }
 
-void CWallet::notifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
+void CWallet::notifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
     NotifyChainLockReceived(pindexChainLock->nHeight);
 }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 7630a7ab03ead..2137f4fe170ab 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -923,7 +923,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     bool CanGetAddresses(bool internal = false) const;
 
     void notifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const instantsend::InstantSendLock>& islock) override;
-    void notifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override;
+    void notifyChainLock(const CBlockIndex* pindexChainLock, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 
     /** Load a CGovernanceObject into m_gobjects. */
     bool LoadGovernanceObject(const Governance::Object& obj) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
diff --git a/src/zmq/zmqabstractnotifier.cpp b/src/zmq/zmqabstractnotifier.cpp
index f65aae46724a1..a38921871534a 100644
--- a/src/zmq/zmqabstractnotifier.cpp
+++ b/src/zmq/zmqabstractnotifier.cpp
@@ -18,7 +18,7 @@ bool CZMQAbstractNotifier::NotifyBlock(const CBlockIndex * /*CBlockIndex*/)
     return true;
 }
 
-bool CZMQAbstractNotifier::NotifyChainLock(const CBlockIndex * /*CBlockIndex*/, const std::shared_ptr<const llmq::CChainLockSig> & /*clsig*/)
+bool CZMQAbstractNotifier::NotifyChainLock(const CBlockIndex * /*CBlockIndex*/, const std::shared_ptr<const chainlock::ChainLockSig> & /*clsig*/)
 {
     return true;
 }
diff --git a/src/zmq/zmqabstractnotifier.h b/src/zmq/zmqabstractnotifier.h
index c292eedd9cfcf..6abee40248593 100644
--- a/src/zmq/zmqabstractnotifier.h
+++ b/src/zmq/zmqabstractnotifier.h
@@ -14,6 +14,9 @@ class CDeterministicMNList;
 class CGovernanceVote;
 class CTransaction;
 class CZMQAbstractNotifier;
+namespace chainlock {
+struct ChainLockSig;
+} // namespace chainlock
 namespace Governance {
 class Object;
 } // namespace Governance
@@ -21,7 +24,6 @@ namespace instantsend {
 struct InstantSendLock;
 } // namespace instantsend
 namespace llmq {
-class CChainLockSig;
 class CRecoveredSig;
 } // namespace llmq
 
@@ -68,7 +70,7 @@ class CZMQAbstractNotifier
     virtual bool NotifyTransactionRemoval(const CTransaction &transaction, uint64_t mempool_sequence);
     // Notifies of transactions added to mempool or appearing in blocks
     virtual bool NotifyTransaction(const CTransaction &transaction);
-    virtual bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig);
+    virtual bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig);
     virtual bool NotifyTransactionLock(const CTransactionRef& transaction, const std::shared_ptr<const instantsend::InstantSendLock>& islock);
     virtual bool NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote);
     virtual bool NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object);
diff --git a/src/zmq/zmqnotificationinterface.cpp b/src/zmq/zmqnotificationinterface.cpp
index dd1f5f8bbc8fc..06e21f8cefef3 100644
--- a/src/zmq/zmqnotificationinterface.cpp
+++ b/src/zmq/zmqnotificationinterface.cpp
@@ -157,7 +157,7 @@ void CZMQNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, co
     });
 }
 
-void CZMQNotificationInterface::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
+void CZMQNotificationInterface::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
     TryForEachAndRemoveFailed(notifiers, [pindex, &clsig](CZMQAbstractNotifier* notifier) {
         return notifier->NotifyChainLock(pindex, clsig);
diff --git a/src/zmq/zmqnotificationinterface.h b/src/zmq/zmqnotificationinterface.h
index e42479df66bea..e0de1074f4d33 100644
--- a/src/zmq/zmqnotificationinterface.h
+++ b/src/zmq/zmqnotificationinterface.h
@@ -31,7 +31,7 @@ class CZMQNotificationInterface final : public CValidationInterface
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override;
     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected) override;
     void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
-    void NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override;
+    void NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
     void NotifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const instantsend::InstantSendLock>& islock) override;
     void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote) override;
     void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object) override;
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
index 017afcb300860..82e0a5660a2f8 100644
--- a/src/zmq/zmqpublishnotifier.cpp
+++ b/src/zmq/zmqpublishnotifier.cpp
@@ -10,10 +10,10 @@
 #include <node/blockstorage.h>
 #include <streams.h>
 
+#include <chainlock/clsig.h>
 #include <governance/common.h>
 #include <governance/vote.h>
 #include <instantsend/lock.h>
-#include <llmq/chainlocks.h>
 #include <llmq/signing.h>
 
 #include <zmq.h>
@@ -232,7 +232,7 @@ bool CZMQPublishHashBlockNotifier::NotifyBlock(const CBlockIndex *pindex)
     return SendZmqMessage(MSG_HASHBLOCK, data, 32);
 }
 
-bool CZMQPublishHashChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
+bool CZMQPublishHashChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
     uint256 hash = pindex->GetBlockHash();
     LogPrint(BCLog::ZMQ, "Publish hashchainlock %s to %s\n", hash.GetHex(), this->address);
@@ -322,7 +322,7 @@ bool CZMQPublishRawBlockNotifier::NotifyBlock(const CBlockIndex *pindex)
     return SendZmqMessage(MSG_RAWBLOCK, &(*ss.begin()), ss.size());
 }
 
-bool CZMQPublishRawChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
+bool CZMQPublishRawChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
     LogPrint(BCLog::ZMQ, "Publish rawchainlock %s to %s\n", pindex->GetBlockHash().GetHex(), this->address);
 
@@ -343,7 +343,7 @@ bool CZMQPublishRawChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex,
     return SendZmqMessage(MSG_RAWCHAINLOCK, &(*ss.begin()), ss.size());
 }
 
-bool CZMQPublishRawChainLockSigNotifier::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)
+bool CZMQPublishRawChainLockSigNotifier::NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
     LogPrint(BCLog::ZMQ, "Publish rawchainlocksig %s to %s\n", pindex->GetBlockHash().GetHex(), this->address);
 
diff --git a/src/zmq/zmqpublishnotifier.h b/src/zmq/zmqpublishnotifier.h
index 507db059291bf..2f1803add73f5 100644
--- a/src/zmq/zmqpublishnotifier.h
+++ b/src/zmq/zmqpublishnotifier.h
@@ -45,7 +45,7 @@ class CZMQPublishHashBlockNotifier : public CZMQAbstractPublishNotifier
 class CZMQPublishHashChainLockNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override;
+    bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 };
 
 class CZMQPublishHashTransactionNotifier : public CZMQAbstractPublishNotifier
@@ -93,13 +93,13 @@ class CZMQPublishRawBlockNotifier : public CZMQAbstractPublishNotifier
 class CZMQPublishRawChainLockNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override;
+    bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 };
 
 class CZMQPublishRawChainLockSigNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) override;
+    bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 };
 
 class CZMQPublishRawTransactionNotifier : public CZMQAbstractPublishNotifier
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 9bfe0d5d5a8a7..6fc42097b579a 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -24,6 +24,11 @@
     # Dash
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorums -> net -> banman",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> banman",
+    "chainlock/chainlock -> instantsend/instantsend -> chainlock/chainlock",
+    "chainlock/chainlock -> instantsend/instantsend -> instantsend/signing -> chainlock/chainlock",
+    "chainlock/chainlock -> instantsend/instantsend -> net_processing -> chainlock/chainlock",
+    "chainlock/chainlock -> validation -> chainlock/chainlock",
+    "chainlock/chainlock -> validation -> evo/chainhelper -> chainlock/chainlock",
     "coinjoin/client -> net_processing -> coinjoin/client",
     "coinjoin/client -> net_processing -> coinjoin/context -> coinjoin/client",
     "coinjoin/context -> coinjoin/server -> net_processing -> coinjoin/context",
@@ -43,14 +48,11 @@
     "governance/governance -> governance/object -> governance/governance",
     "governance/governance -> masternode/sync -> governance/governance",
     "governance/governance -> net_processing -> governance/governance",
-    "instantsend/instantsend -> llmq/chainlocks -> instantsend/instantsend",
     "instantsend/instantsend -> net_processing -> instantsend/instantsend",
     "instantsend/instantsend -> net_processing -> llmq/context -> instantsend/instantsend",
     "instantsend/instantsend -> txmempool -> instantsend/instantsend",
     "llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> llmq/blockprocessor",
-    "llmq/chainlocks -> validation -> llmq/chainlocks",
     "llmq/commitment -> llmq/utils -> llmq/snapshot -> llmq/commitment",
-    "llmq/chainlocks -> llmq/signing -> net_processing -> llmq/chainlocks",
     "llmq/context -> llmq/signing -> net_processing -> llmq/context",
     "llmq/dkgsession -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler -> llmq/dkgsession",
     "llmq/dkgsessionhandler -> net_processing -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler",
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 543203f003996..738a3863cd2fa 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -4,6 +4,8 @@ src/bls/*.cpp
 src/bls/*.h
 src/cachemap.h
 src/cachemultimap.h
+src/chainlock/*.cpp
+src/chainlock/*.h
 src/coinjoin/*.cpp
 src/coinjoin/*.h
 src/ctpl_stl.h