From f10912b9228aa9c62819d697460c36abe7d13bd8 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Fri, 25 Jul 2025 09:30:31 +0000
Subject: [PATCH 01/10] refactor: `llmq/clsig.{cpp,h}` >
 `chainlock/clsig.{cpp,h}`

---
 src/Makefile.am                   |  4 ++--
 src/{llmq => chainlock}/clsig.cpp |  3 ++-
 src/{llmq => chainlock}/clsig.h   |  6 +++---
 src/evo/specialtxman.cpp          | 10 ++++++----
 src/llmq/chainlocks.h             |  2 +-
 src/test/llmq_chainlock_tests.cpp |  3 ++-
 src/test/util/llmq_tests.h        | 10 ++++++----
 src/zmq/zmqpublishnotifier.cpp    |  2 +-
 test/util/data/non-backported.txt |  2 ++
 9 files changed, 25 insertions(+), 17 deletions(-)
 rename src/{llmq => chainlock}/clsig.cpp (96%)
 rename src/{llmq => chainlock}/clsig.h (90%)

diff --git a/src/Makefile.am b/src/Makefile.am
index 55c8f03ae475..37edee6daafe 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -150,6 +150,7 @@ BITCOIN_CORE_H = \
   cachemultimap.h \
   blockfilter.h \
   chain.h \
+  chainlock/clsig.h \
   chainparams.h \
   chainparamsbase.h \
   chainparamsseeds.h \
@@ -240,7 +241,6 @@ BITCOIN_CORE_H = \
   limitedmap.h \
   llmq/blockprocessor.h \
   llmq/chainlocks.h \
-  llmq/clsig.h \
   llmq/commitment.h \
   llmq/context.h \
   llmq/debug.h \
@@ -455,6 +455,7 @@ libbitcoin_node_a_SOURCES = \
   blockencodings.cpp \
   blockfilter.cpp \
   chain.cpp \
+  chainlock/clsig.cpp \
   coinjoin/coinjoin.cpp \
   coinjoin/context.cpp \
   coinjoin/server.cpp \
@@ -499,7 +500,6 @@ libbitcoin_node_a_SOURCES = \
   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/llmq/clsig.cpp b/src/chainlock/clsig.cpp
similarity index 96%
rename from src/llmq/clsig.cpp
rename to src/chainlock/clsig.cpp
index 686b2d15bfcf..b257292e8ad6 100644
--- a/src/llmq/clsig.cpp
+++ b/src/chainlock/clsig.cpp
@@ -2,7 +2,8 @@
 // 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 <chainlock/clsig.h>
+
 #include <tinyformat.h>
 
 namespace llmq {
diff --git a/src/llmq/clsig.h b/src/chainlock/clsig.h
similarity index 90%
rename from src/llmq/clsig.h
rename to src/chainlock/clsig.h
index f8e0ea9629ac..53ea62b70a65 100644
--- a/src/llmq/clsig.h
+++ b/src/chainlock/clsig.h
@@ -2,8 +2,8 @@
 // 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
+#ifndef BITCOIN_CHAINLOCK_CLSIG_H
+#define BITCOIN_CHAINLOCK_CLSIG_H
 
 #include <bls/bls.h>
 #include <serialize.h>
@@ -43,4 +43,4 @@ class CChainLockSig
 };
 } // namespace llmq
 
-#endif // BITCOIN_LLMQ_CLSIG_H
+#endif // BITCOIN_CHAINLOCK_CLSIG_H
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index f0141922f460..16e4389747ae 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -8,6 +8,12 @@
 #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/clsig.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 #include <evo/creditpool.h>
@@ -16,13 +22,9 @@
 #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)
diff --git a/src/llmq/chainlocks.h b/src/llmq/chainlocks.h
index c91fa946bc01..b6f5a43bfa80 100644
--- a/src/llmq/chainlocks.h
+++ b/src/llmq/chainlocks.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_LLMQ_CHAINLOCKS_H
 #define BITCOIN_LLMQ_CHAINLOCKS_H
 
-#include <llmq/clsig.h>
+#include <chainlock/clsig.h>
 
 #include <crypto/common.h> // For ReadLE64
 #include <llmq/signing.h>
diff --git a/src/test/llmq_chainlock_tests.cpp b/src/test/llmq_chainlock_tests.cpp
index 0f364b1e4046..92b6a6f2a0dd 100644
--- a/src/test/llmq_chainlock_tests.cpp
+++ b/src/test/llmq_chainlock_tests.cpp
@@ -5,10 +5,11 @@
 #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 namespace llmq;
diff --git a/src/test/util/llmq_tests.h b/src/test/util/llmq_tests.h
index baa5d14bd3f5..1a625413084f 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 {
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
index 017afcb30086..bf8263ef0efe 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>
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 543203f00399..738a3863cd2f 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

From 021062cd3167ac63ea101408afba78a58fffa7f5 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 23 Jul 2025 08:28:19 +0000
Subject: [PATCH 02/10] refactor: `llmq/chainlocks.{cpp,h}` >
 `chainlock/chainlock.{cpp,h}`

---
 src/Makefile.am                                     |  4 ++--
 src/bench/rpc_blockchain.cpp                        |  2 +-
 .../chainlocks.cpp => chainlock/chainlock.cpp}      | 13 +++++++------
 src/{llmq/chainlocks.h => chainlock/chainlock.h}    |  6 +++---
 src/coinjoin/coinjoin.cpp                           | 13 +++++++------
 src/dsnotificationinterface.cpp                     |  2 +-
 src/evo/chainhelper.cpp                             |  3 ++-
 src/evo/specialtxman.cpp                            |  2 +-
 src/instantsend/instantsend.cpp                     |  4 ++--
 src/instantsend/signing.cpp                         |  2 +-
 src/llmq/context.cpp                                |  2 +-
 src/net_processing.cpp                              |  2 +-
 src/node/interfaces.cpp                             |  2 +-
 src/node/miner.cpp                                  |  2 +-
 src/rest.cpp                                        |  2 +-
 src/rpc/blockchain.cpp                              |  4 ++--
 src/rpc/mining.cpp                                  |  2 +-
 src/rpc/quorums.cpp                                 |  5 ++---
 src/rpc/rawtransaction.cpp                          |  2 +-
 src/test/fuzz/process_message.cpp                   |  1 -
 src/test/miner_tests.cpp                            | 13 +++++++------
 src/validation.cpp                                  |  2 +-
 src/wallet/rpc/wallet.cpp                           |  1 -
 test/lint/lint-circular-dependencies.py             |  8 +++++---
 24 files changed, 51 insertions(+), 48 deletions(-)
 rename src/{llmq/chainlocks.cpp => chainlock/chainlock.cpp} (99%)
 rename src/{llmq/chainlocks.h => chainlock/chainlock.h} (97%)

diff --git a/src/Makefile.am b/src/Makefile.am
index 37edee6daafe..4097a3cb5f00 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -150,6 +150,7 @@ BITCOIN_CORE_H = \
   cachemultimap.h \
   blockfilter.h \
   chain.h \
+  chainlock/chainlock.h \
   chainlock/clsig.h \
   chainparams.h \
   chainparamsbase.h \
@@ -240,7 +241,6 @@ BITCOIN_CORE_H = \
   key_io.h \
   limitedmap.h \
   llmq/blockprocessor.h \
-  llmq/chainlocks.h \
   llmq/commitment.h \
   llmq/context.h \
   llmq/debug.h \
@@ -455,6 +455,7 @@ libbitcoin_node_a_SOURCES = \
   blockencodings.cpp \
   blockfilter.cpp \
   chain.cpp \
+  chainlock/chainlock.cpp \
   chainlock/clsig.cpp \
   coinjoin/coinjoin.cpp \
   coinjoin/context.cpp \
@@ -499,7 +500,6 @@ libbitcoin_node_a_SOURCES = \
   instantsend/lock.cpp \
   instantsend/signing.cpp \
   llmq/blockprocessor.cpp \
-  llmq/chainlocks.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 33fc11065d89..9ed1fffb2f78 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 99%
rename from src/llmq/chainlocks.cpp
rename to src/chainlock/chainlock.cpp
index 155e1117260a..94d9d0d35b57 100644
--- a/src/llmq/chainlocks.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -2,19 +2,14 @@
 // 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,6 +17,12 @@
 #include <validation.h>
 #include <validationinterface.h>
 
+#include <instantsend/instantsend.h>
+#include <llmq/quorums.h>
+#include <masternode/sync.h>
+#include <spork.h>
+#include <stats/client.h>
+
 using node::ReadBlockFromDisk;
 
 // Forward declaration to break dependency over node/transaction.h
diff --git a/src/llmq/chainlocks.h b/src/chainlock/chainlock.h
similarity index 97%
rename from src/llmq/chainlocks.h
rename to src/chainlock/chainlock.h
index b6f5a43bfa80..ac668b6b40c2 100644
--- a/src/llmq/chainlocks.h
+++ b/src/chainlock/chainlock.h
@@ -2,8 +2,8 @@
 // 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 <chainlock/clsig.h>
 
@@ -130,4 +130,4 @@ class CChainLocksHandler : public CRecoveredSigsListener
 bool AreChainLocksEnabled(const CSporkManager& sporkman);
 } // namespace llmq
 
-#endif // BITCOIN_LLMQ_CHAINLOCKS_H
+#endif // BITCOIN_CHAINLOCK_CHAINLOCK_H
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 641a1e7c02d3..07ddb2018090 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 184689904ca4..4e89af48c29d 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>
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
index bda004ab14b3..d4661d71b724 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 16e4389747ae..2a4764ac0d37 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -13,6 +13,7 @@
 #include <util/irange.h>
 #include <validation.h>
 
+#include <chainlock/chainlock.h>
 #include <chainlock/clsig.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
@@ -21,7 +22,6 @@
 #include <evo/mnhftx.h>
 #include <evo/simplifiedmns.h>
 #include <llmq/blockprocessor.h>
-#include <llmq/chainlocks.h>
 #include <llmq/commitment.h>
 #include <llmq/quorums.h>
 #include <llmq/utils.h>
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
index 4a228bc18537..ea182b3dfb60 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 7fb3c7d8ecff..46ea06702de6 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/llmq/context.cpp b/src/llmq/context.cpp
index 87ed6f4709fe..e2a60f21420b 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 1d634907c5bc..f4096b0c00e0 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>
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 493c8606c86c..62fc9fe3a86e 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>
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 7409093904b0..afaefbdc8467 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>
diff --git a/src/rest.cpp b/src/rest.cpp
index 790b55af47ac..9771a2f62327 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 ae6ca2b23ea8..dbe65d1cc0f3 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>
 
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index ec3723e1d9bd..d3d28d516c00 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 f0854b337174..56f7f23f5baa 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>
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 27aa042a927f..12b4ef570914 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 5b458ba0a541..73f255cbf841 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/miner_tests.cpp b/src/test/miner_tests.cpp
index bcd497bb320b..e7f6bb7a5fc1 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/validation.cpp b/src/validation.cpp
index 29ce4c2184eb..e97254b8a7e8 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/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index 9a3cc0c288e8..d82d04342469 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/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 9bfe0d5d5a8a..6fc42097b579 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",

From ef15fee5866d17510f01c0f76bda47c71835d0b1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Fri, 25 Jul 2025 09:31:59 +0000
Subject: [PATCH 03/10] refactor: cleanup `src/chainlock/clsig.*`, move to
 dedicated namespace

---
 src/chainlock/chainlock.cpp          | 22 ++++++++---------
 src/chainlock/chainlock.h            | 12 ++++-----
 src/chainlock/clsig.cpp              | 34 ++++++++++++-------------
 src/chainlock/clsig.h                | 35 ++++++++++++--------------
 src/dsnotificationinterface.cpp      |  3 ++-
 src/dsnotificationinterface.h        |  2 +-
 src/evo/specialtxman.cpp             |  2 +-
 src/interfaces/chain.h               |  8 +++---
 src/net_processing.cpp               |  4 +--
 src/node/interfaces.cpp              |  2 +-
 src/node/miner.cpp                   |  2 +-
 src/rpc/blockchain.cpp               |  2 +-
 src/rpc/quorums.cpp                  |  5 ++--
 src/test/llmq_chainlock_tests.cpp    | 37 ++++++++++++++--------------
 src/test/util/llmq_tests.h           |  4 +--
 src/validationinterface.cpp          |  2 +-
 src/validationinterface.h            |  8 +++---
 src/wallet/wallet.cpp                |  2 +-
 src/wallet/wallet.h                  |  2 +-
 src/zmq/zmqabstractnotifier.cpp      |  2 +-
 src/zmq/zmqabstractnotifier.h        |  6 +++--
 src/zmq/zmqnotificationinterface.cpp |  2 +-
 src/zmq/zmqnotificationinterface.h   |  2 +-
 src/zmq/zmqpublishnotifier.cpp       |  6 ++---
 src/zmq/zmqpublishnotifier.h         |  6 ++---
 25 files changed, 107 insertions(+), 105 deletions(-)

diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index 94d9d0d35b57..036b7f72aaca 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -86,7 +86,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);
 
@@ -99,13 +99,13 @@ 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,
+MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId from, const chainlock::ChainLockSig& clsig,
                                                                 const uint256& hash)
 {
     CheckActiveState();
@@ -221,7 +221,7 @@ void CChainLocksHandler::CheckActiveState()
         // to disable spork19)
         LOCK(cs);
         bestChainLockHash = uint256();
-        bestChainLock = bestChainLockWithKnownBlock = CChainLockSig();
+        bestChainLock = bestChainLockWithKnownBlock = chainlock::ChainLockSig();
         bestChainLockBlockIndex = lastNotifyChainLockBlockIndex = nullptr;
     }
 }
@@ -325,7 +325,7 @@ void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
         }
     }
 
-    uint256 requestId = ::SerializeHash(std::make_pair(CLSIG_REQUESTID_PREFIX, pindex->nHeight));
+    uint256 requestId = ::SerializeHash(std::make_pair(chainlock::CLSIG_REQUESTID_PREFIX, pindex->nHeight));
     uint256 msgHash = pindex->GetBlockHash();
 
     {
@@ -461,7 +461,7 @@ 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;
     {
@@ -471,7 +471,7 @@ void CChainLocksHandler::EnforceBestChainLock()
             return;
         }
 
-        clsig = std::make_shared<CChainLockSig>(bestChainLockWithKnownBlock);
+        clsig = std::make_shared<chainlock::ChainLockSig>(bestChainLockWithKnownBlock);
         pindex = currentBestChainLockBlockIndex = this->bestChainLockBlockIndex;
 
         if (currentBestChainLockBlockIndex == nullptr) {
@@ -517,7 +517,7 @@ MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CR
         return {};
     }
 
-    CChainLockSig clsig;
+    chainlock::ChainLockSig clsig;
     {
         LOCK(cs);
 
@@ -531,7 +531,7 @@ MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CR
         }
 
 
-        clsig = CChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
+        clsig = chainlock::ChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
     }
     return ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
 }
@@ -543,10 +543,10 @@ bool CChainLocksHandler::HasChainLock(int nHeight, const uint256& blockHash) con
 }
 
 
-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());
 }
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
index ac668b6b40c2..f1c9a199c571 100644
--- a/src/chainlock/chainlock.h
+++ b/src/chainlock/chainlock.h
@@ -61,9 +61,9 @@ class CChainLocksHandler : public CRecoveredSigsListener
     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};
 
@@ -94,10 +94,10 @@ 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);
 
-    [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const CChainLockSig& clsig,
+    [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const chainlock::ChainLockSig& clsig,
                                                               const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     void AcceptedBlockHeader(gsl::not_null<const CBlockIndex*> pindexNew) EXCLUSIVE_LOCKS_REQUIRED(!cs);
@@ -113,7 +113,7 @@ class CChainLocksHandler : public CRecoveredSigsListener
 
     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;
+    VerifyRecSigStatus VerifyChainLock(const chainlock::ChainLockSig& clsig) const;
 
     bool IsTxSafeForMining(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
diff --git a/src/chainlock/clsig.cpp b/src/chainlock/clsig.cpp
index b257292e8ad6..163c8bad5271 100644
--- a/src/chainlock/clsig.cpp
+++ b/src/chainlock/clsig.cpp
@@ -6,23 +6,21 @@
 
 #include <tinyformat.h>
 
-namespace llmq {
-    const std::string CLSIG_REQUESTID_PREFIX = "clsig";
+namespace chainlock {
+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();
-    }
+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
index 53ea62b70a65..9efd399c2789 100644
--- a/src/chainlock/clsig.h
+++ b/src/chainlock/clsig.h
@@ -5,42 +5,39 @@
 #ifndef BITCOIN_CHAINLOCK_CLSIG_H
 #define BITCOIN_CHAINLOCK_CLSIG_H
 
-#include <bls/bls.h>
 #include <serialize.h>
 #include <uint256.h>
 
-namespace llmq
-{
+#include <bls/bls.h>
+
+#include <cstdint>
 
+namespace chainlock {
 extern const std::string CLSIG_REQUESTID_PREFIX;
 
-class CChainLockSig
-{
+struct ChainLockSig {
 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;
+    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(CChainLockSig, obj)
+    SERIALIZE_METHODS(ChainLockSig, obj)
     {
         READWRITE(obj.nHeight, obj.blockHash, obj.sig);
     }
 };
-} // namespace llmq
+} // namespace chainlock
 
 #endif // BITCOIN_CHAINLOCK_CLSIG_H
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index 4e89af48c29d..1b6d80b68737 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -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 92ee04aac1d3..6ca8634e2cc1 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/specialtxman.cpp b/src/evo/specialtxman.cpp
index 2a4764ac0d37..80fc0cabbb97 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -78,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/interfaces/chain.h b/src/interfaces/chain.h
index 5dc214fa54a7..19ebf9d6f3bf 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/net_processing.cpp b/src/net_processing.cpp
index f4096b0c00e0..eb57d9ee1b5a 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -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 62fc9fe3a86e..3f08db154699 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -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 afaefbdc8467..8b2626570da1 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -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/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index dbe65d1cc0f3..b9fb546903a4 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -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/quorums.cpp b/src/rpc/quorums.cpp
index 56f7f23f5baa..c25cb717dfb2 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -1020,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;
 },
     };
 }
@@ -1131,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/test/llmq_chainlock_tests.cpp b/src/test/llmq_chainlock_tests.cpp
index 92b6a6f2a0dd..69857f193b8b 100644
--- a/src/test/llmq_chainlock_tests.cpp
+++ b/src/test/llmq_chainlock_tests.cpp
@@ -12,6 +12,7 @@
 
 #include <boost/test/unit_test.hpp>
 
+using chainlock::ChainLockSig;
 using namespace llmq;
 using namespace llmq::testutils;
 
@@ -20,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());
@@ -31,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);
@@ -40,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
@@ -57,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());
@@ -75,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());
@@ -95,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());
 }
@@ -123,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());
@@ -132,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;
@@ -153,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/util/llmq_tests.h b/src/test/util/llmq_tests.h
index 1a625413084f..7859f28679ec 100644
--- a/src/test/util/llmq_tests.h
+++ b/src/test/util/llmq_tests.h
@@ -66,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/validationinterface.cpp b/src/validationinterface.cpp
index e3594469a0c9..c0acb1a4ee4d 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 5cb6bb96edcb..dc20388ddfc6 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/wallet.cpp b/src/wallet/wallet.cpp
index dc6be0d2d13e..698f7ee41799 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 7630a7ab03ea..2137f4fe170a 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 f65aae46724a..a38921871534 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 c292eedd9cfc..6abee4024859 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 dd1f5f8bbc8f..06e21f8cefef 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 e42479df66be..e0de1074f4d3 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 bf8263ef0efe..82e0a5660a2f 100644
--- a/src/zmq/zmqpublishnotifier.cpp
+++ b/src/zmq/zmqpublishnotifier.cpp
@@ -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 507db059291b..2f1803add73f 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

From 5663eac5674c11a0463ee06294b1d04e66ee2f4b Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 17 Jul 2025 08:59:42 +0000
Subject: [PATCH 04/10] refactor: split `Cleanup()`'s masternode and
 non-masternode concerns

We can safely move the entire chunk to `CleanupSigner()` because
`blockTxes` is populated only for the signer's sake, if we aren't
signing, `blockTxes` won't be populated and there would be nothing to
iterate upon.

This will become more apparent as we isolate signer code from the
manager.
---
 src/chainlock/chainlock.cpp | 41 +++++++++++++++++++++++--------------
 src/chainlock/chainlock.h   |  2 ++
 2 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index 036b7f72aaca..d9de2d05ea3c 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -627,23 +627,16 @@ 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) {
-                txFirstSeenTime.erase(txid);
-            }
-            it = blockTxs.erase(it);
-        } else if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            it = blockTxs.erase(it);
-        } else {
-            ++it;
+    LOCK(cs);
+    for (const auto& tx : CleanupSigner()) {
+        for (const auto& txid : *tx) {
+            txFirstSeenTime.erase(txid);
         }
     }
+
+    // need mempool.cs due to GetTransaction calls
+    LOCK2(::cs_main, mempool.cs);
     for (auto it = txFirstSeenTime.begin(); it != txFirstSeenTime.end(); ) {
         uint256 hashBlock;
         if (auto tx = GetTransaction(nullptr, &mempool, it->first, Params().GetConsensus(), hashBlock); !tx) {
@@ -663,9 +656,27 @@ void CChainLocksHandler::Cleanup()
     }
 }
 
+std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CChainLocksHandler::CleanupSigner()
+{
+    AssertLockHeld(cs);
+    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> removed;
+    LOCK(::cs_main);
+    for (auto it = blockTxs.begin(); it != blockTxs.end(); ) {
+        const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);
+        if (InternalHasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            removed.push_back(it->second);
+            it = blockTxs.erase(it);
+        } else if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            it = blockTxs.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    return removed;
+}
+
 bool AreChainLocksEnabled(const CSporkManager& sporkman)
 {
     return sporkman.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
 }
-
 } // namespace llmq
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
index f1c9a199c571..937de2e34647 100644
--- a/src/chainlock/chainlock.h
+++ b/src/chainlock/chainlock.h
@@ -125,6 +125,8 @@ class CChainLocksHandler : public CRecoveredSigsListener
     BlockTxs::mapped_type GetBlockTxs(const uint256& blockHash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CleanupSigner()
+        EXCLUSIVE_LOCKS_REQUIRED(cs);
 };
 
 bool AreChainLocksEnabled(const CSporkManager& sporkman);

From 7e0a3f8d231eed228bf48c4097e558d309a8810d Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 16 Jul 2025 16:18:25 +0000
Subject: [PATCH 05/10] refactor: move masternode mode logic to
 `chainlock/signer.{cpp,h}`

Review with `git log -p -n1 --color-moved=dimmed_zebra`.
---
 src/Makefile.am             |   1 +
 src/chainlock/chainlock.cpp | 225 +----------------------------------
 src/chainlock/signing.cpp   | 230 ++++++++++++++++++++++++++++++++++++
 3 files changed, 234 insertions(+), 222 deletions(-)
 create mode 100644 src/chainlock/signing.cpp

diff --git a/src/Makefile.am b/src/Makefile.am
index 4097a3cb5f00..481238c9fb14 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -457,6 +457,7 @@ libbitcoin_node_a_SOURCES = \
   chain.cpp \
   chainlock/chainlock.cpp \
   chainlock/clsig.cpp \
+  chainlock/signing.cpp \
   coinjoin/coinjoin.cpp \
   coinjoin/context.cpp \
   coinjoin/server.cpp \
diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index d9de2d05ea3c..4be95ffcc2bb 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -7,7 +7,6 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <node/blockstorage.h>
 #include <node/interface_ui.h>
 #include <scheduler.h>
 #include <txmempool.h>
@@ -23,23 +22,15 @@
 #include <spork.h>
 #include <stats/client.h>
 
-using node::ReadBlockFromDisk;
-
 // 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)
-{
-    return sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) == 0;
-}
+using node::GetTransaction;
 
-namespace llmq
-{
+namespace llmq {
 CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
                                        CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
                                        const CMasternodeSync& mn_sync, bool is_masternode) :
@@ -226,122 +217,6 @@ void CChainLocksHandler::CheckActiveState()
     }
 }
 
-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(chainlock::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()) {
@@ -391,55 +266,6 @@ void CChainLocksHandler::BlockDisconnected(const std::shared_ptr<const CBlock>&
     blockTxs.erase(pindexDisconnected->GetBlockHash());
 }
 
-CChainLocksHandler::BlockTxs::mapped_type CChainLocksHandler::GetBlockTxs(const uint256& blockHash)
-{
-    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;
-}
-
 bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const
 {
     int64_t txAge = 0;
@@ -511,38 +337,12 @@ void CChainLocksHandler::EnforceBestChainLock()
     ::g_stats_client->gauge("chainlocks.blockHeight", clsig->getHeight(), 1.0f);
 }
 
-MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
-{
-    if (!isEnabled) {
-        return {};
-    }
-
-    chainlock::ChainLockSig 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 = chainlock::ChainLockSig(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 chainlock::ChainLockSig& clsig) const
 {
     const auto llmqType = Params().GetConsensus().llmqTypeChainLocks;
@@ -656,25 +456,6 @@ void CChainLocksHandler::Cleanup()
     }
 }
 
-std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CChainLocksHandler::CleanupSigner()
-{
-    AssertLockHeld(cs);
-    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> removed;
-    LOCK(::cs_main);
-    for (auto it = blockTxs.begin(); it != blockTxs.end(); ) {
-        const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);
-        if (InternalHasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            removed.push_back(it->second);
-            it = blockTxs.erase(it);
-        } else if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            it = blockTxs.erase(it);
-        } else {
-            ++it;
-        }
-    }
-    return removed;
-}
-
 bool AreChainLocksEnabled(const CSporkManager& sporkman)
 {
     return sporkman.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
new file mode 100644
index 000000000000..67dbcfd2ea59
--- /dev/null
+++ b/src/chainlock/signing.cpp
@@ -0,0 +1,230 @@
+// 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 <node/blockstorage.h>
+#include <txmempool.h>
+#include <validation.h>
+
+#include <chainlock/chainlock.h>
+#include <chainlock/clsig.h>
+#include <instantsend/instantsend.h>
+#include <masternode/sync.h>
+#include <spork.h>
+
+using node::ReadBlockFromDisk;
+
+namespace llmq {
+static bool ChainLocksSigningEnabled(const CSporkManager& sporkman)
+{
+    return sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) == 0;
+}
+
+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(chainlock::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);
+}
+
+CChainLocksHandler::BlockTxs::mapped_type CChainLocksHandler::GetBlockTxs(const uint256& blockHash)
+{
+    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;
+}
+
+MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
+{
+    if (!isEnabled) {
+        return {};
+    }
+
+    chainlock::ChainLockSig 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 = chainlock::ChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
+    }
+    return ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
+}
+
+std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CChainLocksHandler::CleanupSigner()
+{
+    AssertLockHeld(cs);
+    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> removed;
+    LOCK(::cs_main);
+    for (auto it = blockTxs.begin(); it != blockTxs.end(); ) {
+        const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);
+        if (InternalHasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            removed.push_back(it->second);
+            it = blockTxs.erase(it);
+        } else if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            it = blockTxs.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    return removed;
+}
+} // namespace llmq

From f469c46158d1fb44ec88e1d7a07cb1de4906399f Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 16 Jul 2025 16:29:16 +0000
Subject: [PATCH 06/10] refactor: inline single-use
 `ChainLocksSigningEnabled()` definition

---
 src/chainlock/signing.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
index 67dbcfd2ea59..61f815c8ac1e 100644
--- a/src/chainlock/signing.cpp
+++ b/src/chainlock/signing.cpp
@@ -15,11 +15,6 @@
 using node::ReadBlockFromDisk;
 
 namespace llmq {
-static bool ChainLocksSigningEnabled(const CSporkManager& sporkman)
-{
-    return sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) == 0;
-}
-
 void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
 {
     Cleanup();
@@ -36,7 +31,8 @@ void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
         return;
     }
 
-    if (!ChainLocksSigningEnabled(spork_manager)) {
+    if (spork_manager.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) != 0) {
+        // ChainLocks signing not enabled
         return;
     }
 

From 74c1b285581485a929e829bc8ece6bbb71104741 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 23 Jul 2025 08:38:51 +0000
Subject: [PATCH 07/10] refactor: separate masternode mode logic into dedicated
 manager class

---
 src/Makefile.am                         |   1 +
 src/chainlock/chainlock.cpp             | 105 +++++++++++++---------
 src/chainlock/chainlock.h               |  42 +++------
 src/chainlock/signing.cpp               | 115 ++++++++++++++----------
 src/chainlock/signing.h                 |  68 ++++++++++++++
 test/lint/lint-circular-dependencies.py |   1 +
 6 files changed, 212 insertions(+), 120 deletions(-)
 create mode 100644 src/chainlock/signing.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 481238c9fb14..1f1cddf3f856 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -152,6 +152,7 @@ BITCOIN_CORE_H = \
   chain.h \
   chainlock/chainlock.h \
   chainlock/clsig.h \
+  chainlock/signing.h \
   chainparams.h \
   chainparamsbase.h \
   chainparamsseeds.h \
diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index 4be95ffcc2bb..653d5590f9ca 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -16,6 +16,7 @@
 #include <validation.h>
 #include <validationinterface.h>
 
+#include <chainlock/signing.h>
 #include <instantsend/instantsend.h>
 #include <llmq/quorums.h>
 #include <masternode/sync.h>
@@ -34,17 +35,18 @@ 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},
+    sigman{_sigman},
+    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}
 {
 }
 
@@ -56,19 +58,26 @@ CChainLocksHandler::~CChainLocksHandler()
 
 void CChainLocksHandler::Start(const llmq::CInstantSendManager& isman)
 {
-    sigman.RegisterRecoveredSigsListener(this);
+    if (m_signer) {
+        sigman.RegisterRecoveredSigsListener(m_signer.get());
+    }
     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) {
+        sigman.UnregisterRecoveredSigsListener(m_signer.get());
+    }
 }
 
 bool CChainLocksHandler::AlreadyHave(const CInv& inv) const
@@ -195,7 +204,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});
     }
@@ -234,36 +246,40 @@ 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) {
+        LOCK(m_signer->cs_signer);
+        auto it = m_signer->blockTxs.find(pindex->GetBlockHash());
+        if (it == m_signer->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 = m_signer->blockTxs.emplace(pindex->GetBlockHash(), std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>()).first;
+        }
+        auto& txids = *it->second;
+        for (const auto& tx : pblock->vtx) {
+            if (!tx->IsCoinBase() && !tx->vin.empty()) {
+                txids.emplace(tx->GetHash());
+            }
+        }
+    }
 }
 
 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) {
+        LOCK(m_signer->cs_signer);
+        m_signer->blockTxs.erase(pindexDisconnected->GetBlockHash());
+    }
 }
 
 bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const
@@ -428,15 +444,18 @@ void CChainLocksHandler::Cleanup()
         }
     }
 
-    LOCK(cs);
-    for (const auto& tx : CleanupSigner()) {
-        for (const auto& txid : *tx) {
-            txFirstSeenTime.erase(txid);
+    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);
+            }
         }
     }
 
-    // need mempool.cs due to GetTransaction calls
-    LOCK2(::cs_main, mempool.cs);
+    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) {
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
index 937de2e34647..b40eaa7baf00 100644
--- a/src/chainlock/chainlock.h
+++ b/src/chainlock/chainlock.h
@@ -7,11 +7,8 @@
 
 #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>
 
@@ -28,15 +25,20 @@ class CMasternodeSync;
 class CScheduler;
 class CSporkManager;
 class CTxMemPool;
+namespace chainlock {
+class ChainLockSigner;
+} // namespace chainlock
 
-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
 {
     static constexpr int64_t CLEANUP_INTERVAL = 1000 * 30;
     static constexpr int64_t CLEANUP_SEEN_TIMEOUT = 24 * 60 * 60 * 1000;
@@ -48,14 +50,14 @@ class CChainLocksHandler : public CRecoveredSigsListener
     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};
@@ -67,17 +69,6 @@ class CChainLocksHandler : public CRecoveredSigsListener
     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);
@@ -106,10 +97,7 @@ 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);
@@ -122,11 +110,9 @@ class CChainLocksHandler : public CRecoveredSigsListener
     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);
-    std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CleanupSigner()
-        EXCLUSIVE_LOCKS_REQUIRED(cs);
+
+    friend class ::chainlock::ChainLockSigner;
 };
 
 bool AreChainLocksEnabled(const CSporkManager& sporkman);
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
index 61f815c8ac1e..4b40a944e8fb 100644
--- a/src/chainlock/signing.cpp
+++ b/src/chainlock/signing.cpp
@@ -2,8 +2,9 @@
 // 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 <txmempool.h>
 #include <validation.h>
 
 #include <chainlock/chainlock.h>
@@ -14,24 +15,32 @@
 
 using node::ReadBlockFromDisk;
 
-namespace llmq {
-void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
+namespace chainlock {
+ChainLockSigner::ChainLockSigner(CChainState& chainstate, llmq::CChainLocksHandler& 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}
 {
-    Cleanup();
+}
 
-    if (!m_is_masternode) {
-        return;
-    }
+ChainLockSigner::~ChainLockSigner() = default;
 
+void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
+{
     if (!m_mn_sync.IsBlockchainSynced()) {
         return;
     }
 
-    if (!isEnabled) {
+    if (!m_clhandler.isEnabled) {
         return;
     }
 
-    if (spork_manager.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) != 0) {
+    if (m_sporkman.GetSporkValue(SPORK_19_CHAINLOCKS_ENABLED) != 0) {
         // ChainLocks signing not enabled
         return;
     }
@@ -48,26 +57,26 @@ void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
     // Later, we'll add the multiple attempts process.
 
     {
-        LOCK(cs);
+        LOCK2(m_clhandler.cs, cs_signer);
 
         if (pindex->nHeight == lastSignedHeight) {
             // already signed this one
             return;
         }
 
-        if (bestChainLock.getHeight() >= pindex->nHeight) {
+        if (m_clhandler.bestChainLock.getHeight() >= pindex->nHeight) {
             // already got the same CLSIG or a better one
             return;
         }
 
-        if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+        if (m_clhandler.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);
+    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
@@ -79,12 +88,12 @@ void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
             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__);
+                LogPrint(BCLog::CHAINLOCKS, "%s -- tip and previous 5 blocks all safe\n", __func__);
                 break;
             }
-            if (HasChainLock(pindexWalk->nHeight, pindexWalk->GetBlockHash())) {
+            if (m_clhandler.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);
+                LogPrint(BCLog::CHAINLOCKS, "%s -- chainlock at height %d\n", __func__, pindexWalk->nHeight);
                 break;
             }
 
@@ -97,15 +106,15 @@ void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
             for (const auto& txid : *txids) {
                 int64_t txAge = 0;
                 {
-                    LOCK(cs);
-                    auto it = txFirstSeenTime.find(txid);
-                    if (it != txFirstSeenTime.end()) {
+                    LOCK(m_clhandler.cs);
+                    auto it = m_clhandler.txFirstSeenTime.find(txid);
+                    if (it != m_clhandler.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__,
+                if (txAge < m_clhandler.WAIT_FOR_ISLOCK_TIMEOUT && !isman.IsLocked(txid)) {
+                    LogPrint(BCLog::CHAINLOCKS, "%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;
                 }
@@ -115,32 +124,36 @@ void CChainLocksHandler::TrySignChainTip(const llmq::CInstantSendManager& isman)
         }
     }
 
-    uint256 requestId = ::SerializeHash(std::make_pair(chainlock::CLSIG_REQUESTID_PREFIX, pindex->nHeight));
+    uint256 requestId = ::SerializeHash(std::make_pair(CLSIG_REQUESTID_PREFIX, pindex->nHeight));
     uint256 msgHash = pindex->GetBlockHash();
 
     {
-        LOCK(cs);
-        if (bestChainLock.getHeight() >= pindex->nHeight) {
+        LOCK(m_clhandler.cs);
+        if (m_clhandler.bestChainLock.getHeight() >= pindex->nHeight) {
             // might have happened while we didn't hold cs
             return;
         }
+    }
+    {
+        LOCK(cs_signer);
         lastSignedHeight = pindex->nHeight;
         lastSignedRequestId = requestId;
         lastSignedMsgHash = msgHash;
     }
 
-    sigman.AsyncSignIfMember(Params().GetConsensus().llmqTypeChainLocks, shareman, requestId, msgHash);
+    m_sigman.AsyncSignIfMember(Params().GetConsensus().llmqTypeChainLocks, m_shareman, requestId, msgHash);
 }
 
-CChainLocksHandler::BlockTxs::mapped_type CChainLocksHandler::GetBlockTxs(const uint256& blockHash)
+ChainLockSigner::BlockTxs::mapped_type ChainLockSigner::GetBlockTxs(const uint256& blockHash)
 {
-    AssertLockNotHeld(cs);
-    AssertLockNotHeld(cs_main);
+    AssertLockNotHeld(cs_signer);
+    AssertLockNotHeld(m_clhandler.cs);
+    AssertLockNotHeld(::cs_main);
 
-    CChainLocksHandler::BlockTxs::mapped_type ret;
+    ChainLockSigner::BlockTxs::mapped_type ret;
 
     {
-        LOCK(cs);
+        LOCK(cs_signer);
         auto it = blockTxs.find(blockHash);
         if (it != blockTxs.end()) {
             ret = it->second;
@@ -149,7 +162,7 @@ CChainLocksHandler::BlockTxs::mapped_type CChainLocksHandler::GetBlockTxs(const
     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__,
+        LogPrint(BCLog::CHAINLOCKS, "%s -- blockTxs for %s not found. Trying ReadBlockFromDisk\n", __func__,
                  blockHash.ToString());
 
         uint32_t blockTime;
@@ -171,51 +184,55 @@ CChainLocksHandler::BlockTxs::mapped_type CChainLocksHandler::GetBlockTxs(const
 
             blockTime = block.nTime;
         }
-
-        LOCK(cs);
-        blockTxs.emplace(blockHash, ret);
-        for (const auto& txid : *ret) {
-            txFirstSeenTime.emplace(txid, blockTime);
+        {
+            LOCK(cs_signer);
+            blockTxs.emplace(blockHash, ret);
+        }
+        {
+            LOCK(m_clhandler.cs);
+            for (const auto& txid : *ret) {
+                m_clhandler.txFirstSeenTime.emplace(txid, blockTime);
+            }
         }
     }
     return ret;
 }
 
-MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
+MessageProcessingResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
 {
-    if (!isEnabled) {
+    if (!m_clhandler.isEnabled) {
         return {};
     }
 
-    chainlock::ChainLockSig clsig;
+    ChainLockSig clsig;
     {
-        LOCK(cs);
+        LOCK2(m_clhandler.cs, 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 (bestChainLock.getHeight() >= lastSignedHeight) {
+        if (m_clhandler.bestChainLock.getHeight() >= lastSignedHeight) {
             // already got the same or a better CLSIG through the CLSIG message
             return {};
         }
 
-        clsig = chainlock::ChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
+        clsig = ChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get());
     }
-    return ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
+    return m_clhandler.ProcessNewChainLock(-1, clsig, ::SerializeHash(clsig));
 }
 
-std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CChainLocksHandler::CleanupSigner()
+std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> ChainLockSigner::Cleanup()
 {
-    AssertLockHeld(cs);
+    AssertLockNotHeld(cs_signer);
     std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> removed;
-    LOCK(::cs_main);
+    LOCK2(::cs_main, cs_signer);
     for (auto it = blockTxs.begin(); it != blockTxs.end(); ) {
         const auto* pindex = m_chainstate.m_blockman.LookupBlockIndex(it->first);
-        if (InternalHasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+        if (m_clhandler.HasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
             removed.push_back(it->second);
             it = blockTxs.erase(it);
-        } else if (InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+        } else if (m_clhandler.HasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
             it = blockTxs.erase(it);
         } else {
             ++it;
@@ -223,4 +240,4 @@ std::vector<std::shared_ptr<std::unordered_set<uint256, StaticSaltedHasher>>> CC
     }
     return removed;
 }
-} // namespace llmq
+} // namespace chainlock
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
new file mode 100644
index 000000000000..82223c34c67a
--- /dev/null
+++ b/src/chainlock/signing.h
@@ -0,0 +1,68 @@
+// 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 <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 ChainLockSigner : public llmq::CRecoveredSigsListener
+{
+private:
+    CChainState& m_chainstate;
+    llmq::CChainLocksHandler& 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, llmq::CChainLocksHandler& clhandler, llmq::CSigningManager& sigman,
+                             llmq::CSigSharesManager& shareman, CSporkManager& sporkman, const CMasternodeSync& mn_sync);
+    ~ChainLockSigner();
+
+    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);
+
+    friend class ::llmq::CChainLocksHandler;
+};
+} // namespace chainlock
+
+#endif // BITCOIN_CHAINLOCK_SIGNING_H
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 6fc42097b579..0228e8422320 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -24,6 +24,7 @@
     # Dash
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorums -> net -> banman",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> banman",
+    "chainlock/chainlock -> chainlock/signing -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> instantsend/signing -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> net_processing -> chainlock/chainlock",

From e742b7b6d59ad79bc8a6d73986a9c8564992f000 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 23 Jul 2025 08:15:47 +0000
Subject: [PATCH 08/10] refactor: remove need for mutual access to private
 members

---
 src/chainlock/chainlock.cpp | 61 ++++++++++++++----------
 src/chainlock/chainlock.h   | 13 ++---
 src/chainlock/signing.cpp   | 95 ++++++++++++++++++++++---------------
 src/chainlock/signing.h     | 10 +++-
 4 files changed, 103 insertions(+), 76 deletions(-)

diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index 653d5590f9ca..b14966c0a3f2 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -32,12 +32,23 @@ CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMe
 using node::GetTransaction;
 
 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.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
+}
+
 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},
     spork_manager{sporkman},
     mempool{_mempool},
     m_mn_sync{mn_sync},
@@ -59,7 +70,7 @@ CChainLocksHandler::~CChainLocksHandler()
 void CChainLocksHandler::Start(const llmq::CInstantSendManager& isman)
 {
     if (m_signer) {
-        sigman.RegisterRecoveredSigsListener(m_signer.get());
+        m_signer->Start();
     }
     scheduler->scheduleEvery([&]() {
         CheckActiveState();
@@ -76,7 +87,7 @@ void CChainLocksHandler::Stop()
 {
     scheduler->stop();
     if (m_signer) {
-        sigman.UnregisterRecoveredSigsListener(m_signer.get());
+        m_signer->Stop();
     }
 }
 
@@ -105,6 +116,15 @@ chainlock::ChainLockSig CChainLocksHandler::GetBestChainLock() const
     return bestChainLock;
 }
 
+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)
 {
@@ -258,30 +278,24 @@ void CChainLocksHandler::BlockConnected(const std::shared_ptr<const CBlock>& pbl
 
     // We need this information later when we try to sign a new tip, so that we can determine if all included TXs are safe.
     if (m_signer) {
-        LOCK(m_signer->cs_signer);
-        auto it = m_signer->blockTxs.find(pindex->GetBlockHash());
-        if (it == m_signer->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 = m_signer->blockTxs.emplace(pindex->GetBlockHash(), std::make_shared<std::unordered_set<uint256, StaticSaltedHasher>>()).first;
-        }
-        auto& txids = *it->second;
-        for (const auto& tx : pblock->vtx) {
-            if (!tx->IsCoinBase() && !tx->vin.empty()) {
-                txids.emplace(tx->GetHash());
-            }
-        }
+        m_signer->UpdateBlockHashTxidMap(pindex->GetBlockHash(), pblock->vtx);
     }
 }
 
 void CChainLocksHandler::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, gsl::not_null<const CBlockIndex*> pindexDisconnected)
 {
     if (m_signer) {
-        LOCK(m_signer->cs_signer);
-        m_signer->blockTxs.erase(pindexDisconnected->GetBlockHash());
+        m_signer->EraseFromBlockHashTxidMap(pindexDisconnected->GetBlockHash());
     }
 }
 
+int32_t CChainLocksHandler::GetBestChainLockHeight() const
+{
+    AssertLockNotHeld(cs);
+    LOCK(cs);
+    return bestChainLock.getHeight();
+}
+
 bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid) const
 {
     int64_t txAge = 0;
@@ -309,7 +323,7 @@ void CChainLocksHandler::EnforceBestChainLock()
     {
         LOCK(cs);
 
-        if (!isEnabled) {
+        if (!IsEnabled()) {
             return;
         }
 
@@ -371,7 +385,7 @@ bool CChainLocksHandler::InternalHasChainLock(int nHeight, const uint256& blockH
 {
     AssertLockHeld(cs);
 
-    if (!isEnabled) {
+    if (!IsEnabled()) {
         return false;
     }
 
@@ -401,7 +415,7 @@ bool CChainLocksHandler::InternalHasConflictingChainLock(int nHeight, const uint
 {
     AssertLockHeld(cs);
 
-    if (!isEnabled) {
+    if (!IsEnabled()) {
         return false;
     }
 
@@ -474,9 +488,4 @@ void CChainLocksHandler::Cleanup()
         }
     }
 }
-
-bool AreChainLocksEnabled(const CSporkManager& sporkman)
-{
-    return sporkman.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
-}
 } // namespace llmq
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
index b40eaa7baf00..bd61dd0f90f0 100644
--- a/src/chainlock/chainlock.h
+++ b/src/chainlock/chainlock.h
@@ -40,16 +40,9 @@ enum class VerifyRecSigStatus;
 
 class CChainLocksHandler
 {
-    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;
     CSporkManager& spork_manager;
     CTxMemPool& mempool;
     const CMasternodeSync& m_mn_sync;
@@ -87,6 +80,8 @@ class CChainLocksHandler
     bool AlreadyHave(const CInv& inv) 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)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const chainlock::ChainLockSig& clsig,
                                                               const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
@@ -103,7 +98,9 @@ class CChainLocksHandler
     bool HasConflictingChainLock(int nHeight, const uint256& blockHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
     VerifyRecSigStatus VerifyChainLock(const chainlock::ChainLockSig& clsig) const;
 
+    [[nodiscard]] int32_t GetBestChainLockHeight() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
     bool IsTxSafeForMining(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    [[nodiscard]] bool IsEnabled() const { return isEnabled; }
 
 private:
     // these require locks to be held already
@@ -111,8 +108,6 @@ class CChainLocksHandler
     bool InternalHasConflictingChainLock(int nHeight, const uint256& blockHash) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs);
-
-    friend class ::chainlock::ChainLockSigner;
 };
 
 bool AreChainLocksEnabled(const CSporkManager& sporkman);
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
index 4b40a944e8fb..a7705d924f64 100644
--- a/src/chainlock/signing.cpp
+++ b/src/chainlock/signing.cpp
@@ -30,13 +30,23 @@ ChainLockSigner::ChainLockSigner(CChainState& chainstate, llmq::CChainLocksHandl
 
 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) {
+    if (!m_clhandler.IsEnabled()) {
         return;
     }
 
@@ -57,23 +67,23 @@ void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
     // Later, we'll add the multiple attempts process.
 
     {
-        LOCK2(m_clhandler.cs, cs_signer);
+        LOCK(cs_signer);
 
         if (pindex->nHeight == lastSignedHeight) {
             // already signed this one
             return;
         }
+    }
 
-        if (m_clhandler.bestChainLock.getHeight() >= pindex->nHeight) {
-            // already got the same CLSIG or a better one
-            return;
-        }
+    if (m_clhandler.GetBestChainLockHeight() >= pindex->nHeight) {
+        // already got the same CLSIG or a better one
+        return;
+    }
 
-        if (m_clhandler.InternalHasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            // don't sign if another conflicting CLSIG is already present. EnforceBestChainLock will later enforce
-            // the correct chain.
-            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);
@@ -104,18 +114,9 @@ void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
             }
 
             for (const auto& txid : *txids) {
-                int64_t txAge = 0;
-                {
-                    LOCK(m_clhandler.cs);
-                    auto it = m_clhandler.txFirstSeenTime.find(txid);
-                    if (it != m_clhandler.txFirstSeenTime.end()) {
-                        txAge = GetTime<std::chrono::seconds>().count() - it->second;
-                    }
-                }
-
-                if (txAge < m_clhandler.WAIT_FOR_ISLOCK_TIMEOUT && !isman.IsLocked(txid)) {
-                    LogPrint(BCLog::CHAINLOCKS, "%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);
+                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;
                 }
             }
@@ -127,12 +128,9 @@ void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
     uint256 requestId = ::SerializeHash(std::make_pair(CLSIG_REQUESTID_PREFIX, pindex->nHeight));
     uint256 msgHash = pindex->GetBlockHash();
 
-    {
-        LOCK(m_clhandler.cs);
-        if (m_clhandler.bestChainLock.getHeight() >= pindex->nHeight) {
-            // might have happened while we didn't hold cs
-            return;
-        }
+    if (m_clhandler.GetBestChainLockHeight() >= pindex->nHeight) {
+        // might have happened while we didn't hold cs
+        return;
     }
     {
         LOCK(cs_signer);
@@ -144,10 +142,34 @@ void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
     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(m_clhandler.cs);
     AssertLockNotHeld(::cs_main);
 
     ChainLockSigner::BlockTxs::mapped_type ret;
@@ -188,31 +210,26 @@ ChainLockSigner::BlockTxs::mapped_type ChainLockSigner::GetBlockTxs(const uint25
             LOCK(cs_signer);
             blockTxs.emplace(blockHash, ret);
         }
-        {
-            LOCK(m_clhandler.cs);
-            for (const auto& txid : *ret) {
-                m_clhandler.txFirstSeenTime.emplace(txid, blockTime);
-            }
-        }
+        m_clhandler.UpdateTxFirstSeenMap(*ret, blockTime);
     }
     return ret;
 }
 
 MessageProcessingResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)
 {
-    if (!m_clhandler.isEnabled) {
+    if (!m_clhandler.IsEnabled()) {
         return {};
     }
 
     ChainLockSig clsig;
     {
-        LOCK2(m_clhandler.cs, cs_signer);
+        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.bestChainLock.getHeight() >= lastSignedHeight) {
+        if (m_clhandler.GetBestChainLockHeight() >= lastSignedHeight) {
             // already got the same or a better CLSIG through the CLSIG message
             return {};
         }
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
index 82223c34c67a..98232ec89ff9 100644
--- a/src/chainlock/signing.h
+++ b/src/chainlock/signing.h
@@ -49,6 +49,14 @@ class ChainLockSigner : public llmq::CRecoveredSigsListener
                              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
@@ -60,8 +68,6 @@ class ChainLockSigner : public llmq::CRecoveredSigsListener
 private:
     [[nodiscard]] BlockTxs::mapped_type GetBlockTxs(const uint256& blockHash)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_signer);
-
-    friend class ::llmq::CChainLocksHandler;
 };
 } // namespace chainlock
 

From 733f7d3c4ba43749a4a130b969f11ff6edd9dc23 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 23 Jul 2025 08:43:52 +0000
Subject: [PATCH 09/10] refactor: remove `Internal*()` function definitions,
 consolidate

---
 src/chainlock/chainlock.cpp | 18 ++++--------------
 src/chainlock/chainlock.h   |  4 ----
 2 files changed, 4 insertions(+), 18 deletions(-)

diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index b14966c0a3f2..1df5d75e0a97 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -367,12 +367,6 @@ void CChainLocksHandler::EnforceBestChainLock()
     ::g_stats_client->gauge("chainlocks.blockHeight", clsig->getHeight(), 1.0f);
 }
 
-bool CChainLocksHandler::HasChainLock(int nHeight, const uint256& blockHash) const
-{
-    LOCK(cs);
-    return InternalHasChainLock(nHeight, blockHash);
-}
-
 VerifyRecSigStatus CChainLocksHandler::VerifyChainLock(const chainlock::ChainLockSig& clsig) const
 {
     const auto llmqType = Params().GetConsensus().llmqTypeChainLocks;
@@ -381,9 +375,10 @@ VerifyRecSigStatus CChainLocksHandler::VerifyChainLock(const chainlock::ChainLoc
     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()) {
         return false;
@@ -407,13 +402,8 @@ 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()) {
         return false;
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
index bd61dd0f90f0..aeb6c2b81606 100644
--- a/src/chainlock/chainlock.h
+++ b/src/chainlock/chainlock.h
@@ -103,10 +103,6 @@ class CChainLocksHandler
     [[nodiscard]] bool IsEnabled() const { 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);
-
     void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 };
 

From fd8af9c7967bc57dd4ecdc50b374ed23597271ce Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Fri, 25 Jul 2025 09:26:23 +0000
Subject: [PATCH 10/10] refactor: abstract away ChainLocks parent
 implementation from signer

---
 src/chainlock/chainlock.cpp             |  1 -
 src/chainlock/chainlock.h               | 26 ++++++++++++++-----------
 src/chainlock/signing.cpp               |  7 +++----
 src/chainlock/signing.h                 | 21 +++++++++++++++++---
 test/lint/lint-circular-dependencies.py |  1 -
 5 files changed, 36 insertions(+), 20 deletions(-)

diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index 1df5d75e0a97..ea1d179dbd31 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -16,7 +16,6 @@
 #include <validation.h>
 #include <validationinterface.h>
 
-#include <chainlock/signing.h>
 #include <instantsend/instantsend.h>
 #include <llmq/quorums.h>
 #include <masternode/sync.h>
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
index aeb6c2b81606..69ba8130ae75 100644
--- a/src/chainlock/chainlock.h
+++ b/src/chainlock/chainlock.h
@@ -12,6 +12,8 @@
 #include <saltedhasher.h>
 #include <sync.h>
 
+#include <chainlock/signing.h>
+
 #include <gsl/pointers.h>
 
 #include <atomic>
@@ -25,9 +27,6 @@ class CMasternodeSync;
 class CScheduler;
 class CSporkManager;
 class CTxMemPool;
-namespace chainlock {
-class ChainLockSigner;
-} // namespace chainlock
 
 using NodeId = int64_t;
 
@@ -38,7 +37,7 @@ class CSigningManager;
 class CSigSharesManager;
 enum class VerifyRecSigStatus;
 
-class CChainLocksHandler
+class CChainLocksHandler final : public chainlock::ChainLockSignerParent
 {
 private:
     CChainState& m_chainstate;
@@ -80,11 +79,12 @@ class CChainLocksHandler
     bool AlreadyHave(const CInv& inv) 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)
+    void UpdateTxFirstSeenMap(const std::unordered_set<uint256, StaticSaltedHasher>& tx, const int64_t& time) override
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     [[nodiscard]] MessageProcessingResult ProcessNewChainLock(NodeId from, const chainlock::ChainLockSig& clsig,
-                                                              const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+                                                              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);
@@ -94,13 +94,17 @@ class CChainLocksHandler
     void CheckActiveState() EXCLUSIVE_LOCKS_REQUIRED(!cs);
     void EnforceBestChainLock() 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);
+    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;
 
-    [[nodiscard]] int32_t GetBestChainLockHeight() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    bool IsTxSafeForMining(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    [[nodiscard]] bool IsEnabled() const { return isEnabled; }
+    [[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:
     void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs);
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
index a7705d924f64..0ef9aa550dfb 100644
--- a/src/chainlock/signing.cpp
+++ b/src/chainlock/signing.cpp
@@ -7,7 +7,6 @@
 #include <node/blockstorage.h>
 #include <validation.h>
 
-#include <chainlock/chainlock.h>
 #include <chainlock/clsig.h>
 #include <instantsend/instantsend.h>
 #include <masternode/sync.h>
@@ -16,9 +15,9 @@
 using node::ReadBlockFromDisk;
 
 namespace chainlock {
-ChainLockSigner::ChainLockSigner(CChainState& chainstate, llmq::CChainLocksHandler& clhandler,
-                                 llmq::CSigningManager& sigman, llmq::CSigSharesManager& shareman,
-                                 CSporkManager& sporkman, const CMasternodeSync& mn_sync) :
+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},
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
index 98232ec89ff9..a07df18265cd 100644
--- a/src/chainlock/signing.h
+++ b/src/chainlock/signing.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_CHAINLOCK_SIGNING_H
 #define BITCOIN_CHAINLOCK_SIGNING_H
 
+#include <chainlock/clsig.h>
 #include <llmq/signing.h>
 
 class CMasternodeSync;
@@ -19,11 +20,25 @@ class CSigSharesManager;
 } // namespace llmq
 
 namespace chainlock {
-class ChainLockSigner : public llmq::CRecoveredSigsListener
+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;
-    llmq::CChainLocksHandler& m_clhandler;
+    ChainLockSignerParent& m_clhandler;
     llmq::CSigningManager& m_sigman;
     llmq::CSigSharesManager& m_shareman;
     CSporkManager& m_sporkman;
@@ -45,7 +60,7 @@ class ChainLockSigner : public llmq::CRecoveredSigsListener
     uint256 lastSignedMsgHash GUARDED_BY(cs_signer);
 
 public:
-    explicit ChainLockSigner(CChainState& chainstate, llmq::CChainLocksHandler& clhandler, llmq::CSigningManager& sigman,
+    explicit ChainLockSigner(CChainState& chainstate, ChainLockSignerParent& clhandler, llmq::CSigningManager& sigman,
                              llmq::CSigSharesManager& shareman, CSporkManager& sporkman, const CMasternodeSync& mn_sync);
     ~ChainLockSigner();
 
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 0228e8422320..6fc42097b579 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -24,7 +24,6 @@
     # Dash
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorums -> net -> banman",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> banman",
-    "chainlock/chainlock -> chainlock/signing -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> instantsend/signing -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> net_processing -> chainlock/chainlock",