refactor: abstract away ChainLocks parent implementation from signer

Author: kwvg

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>

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);

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},

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();
 

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",