refactor: cleanup src/chainlock/clsig.*, move to dedicated namespace

Author: kwvg

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

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

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

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

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

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;

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

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

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

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