chore: clang format

Author: PastaPastaPasta

src/chainlock/chainlock.cpp

@@ -496,55 +496,54 @@ void CChainLocksHandler::Cleanup()
 
 void CChainLocksHandler::QueueCoinbaseChainLock(const chainlock::ChainLockSig& clsig)
 {
-    AssertLockNotHeld(cs);
     LOCK(cs);
-    
+
     if (!IsEnabled()) {
         return;
     }
-    
+
     // Only queue if it's potentially newer than what we have
     if (!bestChainLock.IsNull() && clsig.getHeight() <= bestChainLock.getHeight()) {
         return;
     }
-    
+
     // Check if we've already seen this chainlock
     const uint256 hash = ::SerializeHash(clsig);
     if (seenChainLocks.count(hash) != 0) {
         return;
     }
-    
+
     pendingCoinbaseChainLocks.push_back(clsig);
 }
 
 void CChainLocksHandler::ProcessPendingCoinbaseChainLocks()
 {
     AssertLockNotHeld(cs);
     AssertLockNotHeld(cs_main);
-    
+
     if (!IsEnabled()) {
         return;
     }
-    
+
     std::vector<chainlock::ChainLockSig> toProcess;
     {
         LOCK(cs);
         if (pendingCoinbaseChainLocks.empty()) {
             return;
         }
-        
+
         // Move all pending chainlocks to a local vector for processing
         toProcess.reserve(pendingCoinbaseChainLocks.size());
         while (!pendingCoinbaseChainLocks.empty()) {
             toProcess.push_back(pendingCoinbaseChainLocks.front());
             pendingCoinbaseChainLocks.pop_front();
         }
     }
-    
+
     // Process each chainlock outside the lock
     for (const auto& clsig : toProcess) {
         const uint256 hash = ::SerializeHash(clsig);
-        
+
         // Check again if we still want to process this (might have been processed via network)
         {
             LOCK(cs);
@@ -555,7 +554,7 @@ void CChainLocksHandler::ProcessPendingCoinbaseChainLocks()
                 continue;
             }
         }
-        
+
         // Process as if it came from a coinbase (from = -1 means internal)
         // Ignore return value as we're processing internally from coinbase
         (void)ProcessNewChainLock(-1, clsig, hash);

src/chainlock/chainlock.h

@@ -132,14 +132,12 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
 
     // Queue a coinbase chainlock for asynchronous processing
     // This is called during block validation to avoid blocking
-    void QueueCoinbaseChainLock(const chainlock::ChainLockSig& clsig)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void QueueCoinbaseChainLock(const chainlock::ChainLockSig& clsig) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
 private:
     void Cleanup()
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
-    void ProcessPendingCoinbaseChainLocks()
-        EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void ProcessPendingCoinbaseChainLocks() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 };
 
 bool AreChainLocksEnabled(const CSporkManager& sporkman);

src/evo/specialtxman.cpp

@@ -651,7 +651,8 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
                 const CBlockIndex* pindexCL = pindex->GetAncestor(curBlockCoinbaseCLHeight);
                 if (pindexCL) {
                     uint256 curBlockCoinbaseCLBlockHash = pindexCL->GetBlockHash();
-                    chainlock::ChainLockSig clsig(curBlockCoinbaseCLHeight, curBlockCoinbaseCLBlockHash, opt_cbTx->bestCLSignature);
+                    chainlock::ChainLockSig clsig(curBlockCoinbaseCLHeight, curBlockCoinbaseCLBlockHash,
+                                                  opt_cbTx->bestCLSignature);
                     m_clhandler.QueueCoinbaseChainLock(clsig);
                 }
             }

src/test/llmq_chainlock_tests.cpp

@@ -8,8 +8,8 @@
 #include <streams.h>
 #include <util/strencodings.h>
 
-#include <chainlock/clsig.h>
 #include <chainlock/chainlock.h>
+#include <chainlock/clsig.h>
 #include <llmq/context.h>
 #include <validation.h>
 
@@ -174,35 +174,30 @@ BOOST_AUTO_TEST_CASE(coinbase_chainlock_queueing_test)
 {
     // Test that coinbase chainlocks can be queued for processing
     // This test verifies the queueing mechanism works without requiring full block processing
-    
+
     TestingSetup test_setup(CBaseChainParams::REGTEST);
-    
+
     // Create a chainlock handler
-    llmq::CChainLocksHandler handler(
-        test_setup.m_node.chainman->ActiveChainstate(),
-        *test_setup.m_node.llmq_ctx->qman,
-        *test_setup.m_node.sporkman,
-        *test_setup.m_node.mempool,
-        *test_setup.m_node.mn_sync
-    );
-    
+    llmq::CChainLocksHandler handler(test_setup.m_node.chainman->ActiveChainstate(), *test_setup.m_node.llmq_ctx->qman,
+                                     *test_setup.m_node.sporkman, *test_setup.m_node.mempool, *test_setup.m_node.mn_sync);
+
     // Create a test chainlock
     int32_t height = 100;
     uint256 blockHash = GetTestBlockHash(100);
     ChainLockSig clsig = CreateChainLock(height, blockHash);
-    
+
     // Verify the chainlock is not null
     BOOST_CHECK(!clsig.IsNull());
     BOOST_CHECK_EQUAL(clsig.getHeight(), height);
-    
+
     // Queue the chainlock (this should not fail even if chainlocks are disabled)
     // The handler will check if chainlocks are enabled internally
     handler.QueueCoinbaseChainLock(clsig);
-    
+
     // Create a newer chainlock
     ChainLockSig clsig2 = CreateChainLock(height + 1, GetTestBlockHash(101));
     handler.QueueCoinbaseChainLock(clsig2);
-    
+
     // Queueing should succeed without errors
     // Note: Actual processing requires chainlocks to be enabled and the scheduler to run,
     // which is tested in functional tests (feature_llmq_chainlocks.py)