From bd2bff16d6c90f5d401ca21468df7bb85647316c Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Sat, 2 May 2026 14:11:29 +0700
Subject: [PATCH 1/4] refactor: move network implementation of spork to
 net_processing

It helps to break circular dependencies over spork <-> net.
It helps to get spork manager ready kernel project.
Apparantly, chainstate implementation uses sporks for validation
of blockchain but network dependencies could be avoided there.
---
 src/net_processing.cpp | 10 ++++++++++
 src/spork.cpp          | 12 ++----------
 src/spork.h            |  6 ++----
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 3f8ba2e11b48..f36f7a3133cc 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -5462,6 +5462,16 @@ void PeerManagerImpl::ProcessMessage(
         return;
     }
 
+    if (msg_type == NetMsgType::GETSPORKS) {
+        // For 'getsporks', active sporks is sent to the requesting peer.
+        auto active_sporks = m_sporkman.ActiveSporks();
+        for (const auto& pair : active_sporks) {
+            for (const auto& signerSporkPair : pair.second) {
+                m_connman.PushMessage(&pfrom, CNetMsgMaker(pfrom.GetCommonVersion()).Make(NetMsgType::SPORK, signerSporkPair.second));
+            }
+        }
+    }
+
     if (msg_type == NetMsgType::QUORUMROTATIONINFO) {
         // we have never requested this
         Misbehaving(pfrom.GetId(), 100, strprintf("received not-requested quorumrotationinfo. peer=%d", pfrom.GetId()));
diff --git a/src/spork.cpp b/src/spork.cpp
index d213dc417423..91254e1984b3 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -12,7 +12,6 @@
 #include <logging.h>
 #include <messagesigner.h>
 #include <net.h>
-#include <netmessagemaker.h>
 #include <protocol.h>
 #include <script/standard.h>
 #include <timedata.h>
@@ -130,8 +129,6 @@ MessageProcessingResult CSporkManager::ProcessMessage(CNode& peer, CConnman& con
 {
     if (msg_type == NetMsgType::SPORK) {
         return ProcessSpork(peer.GetId(), vRecv);
-    } else if (msg_type == NetMsgType::GETSPORKS) {
-        ProcessGetSporks(peer, connman);
     }
     return {};
 }
@@ -195,17 +192,12 @@ MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vR
     return ret;
 }
 
-void CSporkManager::ProcessGetSporks(CNode& peer, CConnman& connman)
+std::unordered_map<SporkId, std::map<CKeyID, CSporkMessage>> CSporkManager::ActiveSporks() const
 {
     LOCK(cs); // make sure to not lock this together with cs_main
-    for (const auto& pair : mapSporksActive) {
-        for (const auto& signerSporkPair : pair.second) {
-            connman.PushMessage(&peer, CNetMsgMaker(peer.GetCommonVersion()).Make(NetMsgType::SPORK, signerSporkPair.second));
-        }
-    }
+    return mapSporksActive;
 }
 
-
 std::optional<CInv> CSporkManager::UpdateSpork(SporkId nSporkID, SporkValue nValue)
 {
     CSporkMessage spork(nSporkID, nValue, GetAdjustedTime());
diff --git a/src/spork.h b/src/spork.h
index 1f9da2b74804..0df2f0b2ac62 100644
--- a/src/spork.h
+++ b/src/spork.h
@@ -264,11 +264,9 @@ class CSporkManager : public SporkStore
         EXCLUSIVE_LOCKS_REQUIRED(!cs, !cs_cache);
 
     /**
-     * ProcessGetSporks is used to handle the 'getsporks' p2p message.
-     *
-     * For 'getsporks', it sends active sporks to the requesting peer.
+     * ActiveSporks is used to handle the 'getsporks' p2p message.
      */
-    void ProcessGetSporks(CNode& peer, CConnman& connman) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    std::unordered_map<SporkId, std::map<CKeyID, CSporkMessage>> ActiveSporks() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     /**
      * UpdateSpork is used by the spork RPC command to set a new spork value, sign

From 7c899a231fc404fbd71fd635b2a5be3696f4ec91 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Sat, 2 May 2026 16:36:38 +0700
Subject: [PATCH 2/4] refactor: drop dependency of spork manager on network
 code

---
 src/net_processing.cpp                  | 19 +++++++++-
 src/spork.cpp                           | 47 +++++++++----------------
 src/spork.h                             | 19 ++++------
 test/lint/lint-circular-dependencies.py |  1 -
 4 files changed, 41 insertions(+), 45 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index f36f7a3133cc..4ad17992b92e 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -5462,6 +5462,23 @@ void PeerManagerImpl::ProcessMessage(
         return;
     }
 
+    if (msg_type == NetMsgType::SPORK) {
+        CSporkMessage spork;
+        vRecv >> spork;
+
+        uint256 hash = spork.GetHash();
+        CInv spork_inv{MSG_SPORK, hash};
+        WITH_LOCK(::cs_main, EraseObjectRequest(pfrom.GetId(), spork_inv));
+        if (!m_sporkman.IsSporkValid(spork)) {
+            Misbehaving(pfrom.GetId(), 100);
+            return;
+        }
+        if (m_sporkman.ProcessSpork(spork)) {
+            RelayInv(spork_inv);
+        }
+        return;
+    }
+
     if (msg_type == NetMsgType::GETSPORKS) {
         // For 'getsporks', active sporks is sent to the requesting peer.
         auto active_sporks = m_sporkman.ActiveSporks();
@@ -5470,6 +5487,7 @@ void PeerManagerImpl::ProcessMessage(
                 m_connman.PushMessage(&pfrom, CNetMsgMaker(pfrom.GetCommonVersion()).Make(NetMsgType::SPORK, signerSporkPair.second));
             }
         }
+        return;
     }
 
     if (msg_type == NetMsgType::QUORUMROTATIONINFO) {
@@ -5518,7 +5536,6 @@ void PeerManagerImpl::ProcessMessage(
             PostProcessMessage(m_cj_walletman->processMessage(pfrom, m_chainman.ActiveChainstate(), m_connman, m_mempool, msg_type, vRecv), pfrom.GetId());
         }
         PostProcessMessage(DKGSessionProcessMessage(pfrom, is_masternode, msg_type, vRecv), pfrom.GetId());
-        PostProcessMessage(m_sporkman.ProcessMessage(pfrom, m_connman, msg_type, vRecv), pfrom.GetId());
         PostProcessMessage(CMNAuth::ProcessMessage(pfrom, peer->m_their_services, m_connman, m_mn_metaman, (m_active_ctx ? m_active_ctx->nodeman.get() : nullptr), m_mn_sync, m_dmnman->GetListAtChainTip(), msg_type, vRecv), pfrom.GetId());
         PostProcessMessage(m_llmq_ctx->quorum_block_processor->ProcessMessage(pfrom, msg_type, vRecv), pfrom.GetId());
         PostProcessMessage(ProcessPlatformBanMessage(pfrom.GetId(), msg_type, vRecv), pfrom.GetId());
diff --git a/src/spork.cpp b/src/spork.cpp
index 91254e1984b3..cf7408d49c59 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -4,17 +4,15 @@
 
 #include <spork.h>
 
-#include <flat-database.h>
-#include <util/helpers.h>
-
 #include <chainparams.h>
+#include <flat-database.h>
 #include <key_io.h>
 #include <logging.h>
 #include <messagesigner.h>
-#include <net.h>
 #include <protocol.h>
 #include <script/standard.h>
 #include <timedata.h>
+#include <util/helpers.h>
 #include <util/message.h> // for MESSAGE_MAGIC
 #include <util/string.h>
 
@@ -125,41 +123,29 @@ void CSporkManager::CheckAndRemove()
     }
 }
 
-MessageProcessingResult CSporkManager::ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
+bool CSporkManager::IsSporkValid(const CSporkMessage& spork)
 {
-    if (msg_type == NetMsgType::SPORK) {
-        return ProcessSpork(peer.GetId(), vRecv);
-    }
-    return {};
-}
-
-MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vRecv)
-{
-    CSporkMessage spork;
-    vRecv >> spork;
-
-    uint256 hash = spork.GetHash();
-
-    MessageProcessingResult ret{};
-    ret.m_to_erase = CInv{MSG_SPORK, hash};
-
     if (spork.nTimeSigned > GetAdjustedTime() + 2 * 60 * 60) {
         LogPrint(BCLog::SPORK, "CSporkManager::ProcessSpork -- ERROR: too far into the future\n");
-        ret.m_error = MisbehavingError{100};
-        return ret;
+        return false;
     }
 
     auto opt_keyIDSigner = spork.GetSignerKeyID();
 
     if (opt_keyIDSigner == std::nullopt || WITH_LOCK(cs, return !setSporkPubKeyIDs.count(*opt_keyIDSigner))) {
         LogPrint(BCLog::SPORK, "CSporkManager::ProcessSpork -- ERROR: invalid signature\n");
-        ret.m_error = MisbehavingError{100};
-        return ret;
+        return false;
     }
+    return true;
+}
 
-    std::string strLogMsg{strprintf("SPORK -- hash: %s id: %d value: %10d peer=%d", hash.ToString(), spork.nSporkID,
-                                    spork.nValue, from)};
-    auto keyIDSigner = *opt_keyIDSigner;
+bool CSporkManager::ProcessSpork(const CSporkMessage& spork)
+{
+    uint256 hash = spork.GetHash();
+    std::string strLogMsg{strprintf("SPORK -- hash: %s id: %d value: %10d", hash.ToString(), spork.nSporkID,
+                                    spork.nValue)};
+    assert(spork.GetSignerKeyID().has_value());
+    auto keyIDSigner = spork.GetSignerKeyID().value();
 
     {
         LOCK(cs); // make sure to not lock this together with cs_main
@@ -167,7 +153,7 @@ MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vR
             if (mapSporksActive[spork.nSporkID].count(keyIDSigner)) {
                 if (mapSporksActive[spork.nSporkID][keyIDSigner].nTimeSigned >= spork.nTimeSigned) {
                     LogPrint(BCLog::SPORK, "%s seen\n", strLogMsg);
-                    return ret;
+                    return false;
                 } else {
                     LogPrintf("%s updated\n", strLogMsg);
                 }
@@ -188,8 +174,7 @@ MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vR
         }
     }
 
-    ret.m_inventory.emplace_back(MSG_SPORK, hash);
-    return ret;
+    return true;
 }
 
 std::unordered_map<SporkId, std::map<CKeyID, CSporkMessage>> CSporkManager::ActiveSporks() const
diff --git a/src/spork.h b/src/spork.h
index 0df2f0b2ac62..33e34cd11493 100644
--- a/src/spork.h
+++ b/src/spork.h
@@ -5,16 +5,11 @@
 #ifndef BITCOIN_SPORK_H
 #define BITCOIN_SPORK_H
 
-#include <msg_result.h>
-
 #include <hash.h>
 #include <key.h>
-#include <net.h>
-#include <net_types.h>
 #include <pubkey.h>
 #include <saltedhasher.h>
 #include <sync.h>
-#include <uint256.h>
 
 #include <array>
 #include <optional>
@@ -22,11 +17,11 @@
 #include <unordered_map>
 #include <vector>
 
-class CConnman;
 template<typename T>
 class CFlatDB;
-class CNode;
 class CDataStream;
+class uint256;
+class CInv;
 
 class CSporkMessage;
 class CSporkManager;
@@ -249,18 +244,18 @@ class CSporkManager : public SporkStore
     void CheckAndRemove() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     /**
-     * ProcessMessage is used to call ProcessSpork and ProcessGetSporks. See below
+     * IsSporkValid validate signed time and pubkey
+     * If these values mismatch function returns false [spork is invalid]
+     * If spork validation failed, peer should be punished
      */
-    [[nodiscard]] MessageProcessingResult ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type,
-                                                         CDataStream& vRecv) EXCLUSIVE_LOCKS_REQUIRED(!cs_cache);
-
+    [[nodiscard]] bool IsSporkValid(const CSporkMessage& spork) EXCLUSIVE_LOCKS_REQUIRED(!cs);
     /**
      * ProcessSpork is used to handle the 'spork' p2p message.
      *
      * For 'spork', it validates the spork and adds it to the internal spork storage and
      * performs any necessary processing.
      */
-    [[nodiscard]] MessageProcessingResult ProcessSpork(NodeId from, CDataStream& vRecv)
+    [[nodiscard]] bool ProcessSpork(const CSporkMessage& spork)
         EXCLUSIVE_LOCKS_REQUIRED(!cs, !cs_cache);
 
     /**
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 96ce0c51fa02..95f8fe6a1d58 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -23,7 +23,6 @@
     # Dash
     "active/context -> active/dkgsessionhandler -> llmq/dkgsessionhandler -> net_processing -> active/context",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> banman",
-    "chainlock/chainlock -> spork -> net -> evo/deterministicmns -> evo/providertx -> validation -> chainlock/chainlock",
     "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> net_processing -> coinjoin/walletman -> coinjoin/client",
     "common/bloom -> evo/assetlocktx -> llmq/commitment -> evo/deterministicmns -> evo/simplifiedmns -> merkleblock -> common/bloom",
     "common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> common/bloom",

From 7460211c6c656c71f0e2180c5ce863dc6d38b0a7 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Sun, 3 May 2026 22:32:41 +0300
Subject: [PATCH 3/4] refactor: address review feedback on spork ProcessMessage
 refactor

- Use __func__ in IsSporkValid log prefixes (was stale "ProcessSpork")
- Mark IsSporkValid as const
- Pass reason string to Misbehaving on invalid spork

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 src/net_processing.cpp | 2 +-
 src/spork.cpp          | 6 +++---
 src/spork.h            | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 4ad17992b92e..a8fde29cc39e 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -5470,7 +5470,7 @@ void PeerManagerImpl::ProcessMessage(
         CInv spork_inv{MSG_SPORK, hash};
         WITH_LOCK(::cs_main, EraseObjectRequest(pfrom.GetId(), spork_inv));
         if (!m_sporkman.IsSporkValid(spork)) {
-            Misbehaving(pfrom.GetId(), 100);
+            Misbehaving(pfrom.GetId(), 100, strprintf("invalid spork received. peer=%d", pfrom.GetId()));
             return;
         }
         if (m_sporkman.ProcessSpork(spork)) {
diff --git a/src/spork.cpp b/src/spork.cpp
index cf7408d49c59..659dc7e8946c 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -123,17 +123,17 @@ void CSporkManager::CheckAndRemove()
     }
 }
 
-bool CSporkManager::IsSporkValid(const CSporkMessage& spork)
+bool CSporkManager::IsSporkValid(const CSporkMessage& spork) const
 {
     if (spork.nTimeSigned > GetAdjustedTime() + 2 * 60 * 60) {
-        LogPrint(BCLog::SPORK, "CSporkManager::ProcessSpork -- ERROR: too far into the future\n");
+        LogPrint(BCLog::SPORK, "CSporkManager::%s -- ERROR: too far into the future\n", __func__);
         return false;
     }
 
     auto opt_keyIDSigner = spork.GetSignerKeyID();
 
     if (opt_keyIDSigner == std::nullopt || WITH_LOCK(cs, return !setSporkPubKeyIDs.count(*opt_keyIDSigner))) {
-        LogPrint(BCLog::SPORK, "CSporkManager::ProcessSpork -- ERROR: invalid signature\n");
+        LogPrint(BCLog::SPORK, "CSporkManager::%s -- ERROR: invalid signature\n", __func__);
         return false;
     }
     return true;
diff --git a/src/spork.h b/src/spork.h
index 33e34cd11493..f4eb1c00d351 100644
--- a/src/spork.h
+++ b/src/spork.h
@@ -248,7 +248,7 @@ class CSporkManager : public SporkStore
      * If these values mismatch function returns false [spork is invalid]
      * If spork validation failed, peer should be punished
      */
-    [[nodiscard]] bool IsSporkValid(const CSporkMessage& spork) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    [[nodiscard]] bool IsSporkValid(const CSporkMessage& spork) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
     /**
      * ProcessSpork is used to handle the 'spork' p2p message.
      *

From 6a4ee5272700a6ad9d93858ebdf49170dc559bdf Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 5 May 2026 18:30:26 +0700
Subject: [PATCH 4/4] fix: replace assert to if-return. Less probability to get
 troubles in the future

---
 src/spork.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/spork.cpp b/src/spork.cpp
index 659dc7e8946c..7ca815bcf6e4 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -144,7 +144,9 @@ bool CSporkManager::ProcessSpork(const CSporkMessage& spork)
     uint256 hash = spork.GetHash();
     std::string strLogMsg{strprintf("SPORK -- hash: %s id: %d value: %10d", hash.ToString(), spork.nSporkID,
                                     spork.nValue)};
-    assert(spork.GetSignerKeyID().has_value());
+
+    if (!spork.GetSignerKeyID().has_value()) return false;
+
     auto keyIDSigner = spork.GetSignerKeyID().value();
 
     {