From 8a4a1934ff94ca9c3b8a42ea4b9b445f5bf6efa4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:11:56 +0700
Subject: [PATCH 01/12] refactor: move RenameThreadPool out of common/system

RenameThreadPool is Dash-only and is called from bls/bls_worker.cpp, which the kernel library builds, while common/system.cpp is a node-side file that upstream bitcoin#27636 keeps out of the kernel. Move the helper next to util::TraceThread in util/thread.{h,cpp}, which the kernel already builds, so the kernel no longer needs common/system.cpp.
---
 src/bls/bls_worker.cpp |  2 +-
 src/common/system.cpp  | 43 -------------------------------------
 src/common/system.h    |  5 -----
 src/util/thread.cpp    | 48 ++++++++++++++++++++++++++++++++++++++++++
 src/util/thread.h      |  7 ++++++
 5 files changed, 56 insertions(+), 49 deletions(-)

diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 7e383a644ba3..be8bef23226e 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -8,7 +8,7 @@
 #include <random.h>
 
 #include <logging.h>
-#include <common/system.h>
+#include <util/thread.h>
 
 #include <algorithm>
 #include <map>
diff --git a/src/common/system.cpp b/src/common/system.cpp
index d9249c264495..f718d27501d1 100644
--- a/src/common/system.cpp
+++ b/src/common/system.cpp
@@ -6,11 +6,8 @@
 
 #include <common/system.h>
 
-#include <ctpl_stl.h>
 #include <logging.h>
-#include <tinyformat.h>
 #include <util/string.h>
-#include <util/threadnames.h>
 #include <util/time.h>
 
 #ifndef WIN32
@@ -24,9 +21,7 @@
 #endif
 
 #include <cstdlib>
-#include <future>
 #include <locale>
-#include <map>
 #include <stdexcept>
 #include <string>
 #include <thread>
@@ -69,44 +64,6 @@ void runCommand(const std::string& strCommand)
 }
 #endif
 
-void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName)
-{
-    auto cond = std::make_shared<std::condition_variable>();
-    auto mutex = std::make_shared<std::mutex>();
-    std::atomic<int> doneCnt(0);
-    std::map<int, std::future<void> > futures;
-
-    for (int i = 0; i < tp.size(); i++) {
-        futures[i] = tp.push([baseName, i, cond, mutex, &doneCnt](int threadId) {
-            util::ThreadRename(strprintf("%s-%d", baseName, i));
-            std::unique_lock<std::mutex> l(*mutex);
-            doneCnt++;
-            cond->wait(l);
-        });
-    }
-
-    do {
-        // Always sleep to let all threads acquire locks
-        UninterruptibleSleep(std::chrono::milliseconds{10});
-        // `doneCnt` should be at least `futures.size()` if tp size was increased (for whatever reason),
-        // or at least `tp.size()` if tp size was decreased and queue was cleared
-        // (which can happen on `stop()` if we were not fast enough to get all jobs to their threads).
-    } while (uint64_t(doneCnt) < futures.size() && doneCnt < tp.size());
-
-    cond->notify_all();
-
-    // Make sure no one is left behind, just in case
-    for (auto& pair : futures) {
-        auto& f = pair.second;
-        if (f.valid() && f.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout) {
-            LogPrintf("%s: %s-%d timed out\n", __func__, baseName, pair.first);
-            // Notify everyone again
-            cond->notify_all();
-            break;
-        }
-    }
-}
-
 void SetupEnvironment()
 {
 #ifdef HAVE_MALLOPT_ARENA_MAX
diff --git a/src/common/system.h b/src/common/system.h
index 8e54b9e526d1..681e9be299d1 100644
--- a/src/common/system.h
+++ b/src/common/system.h
@@ -36,11 +36,6 @@ std::string ShellEscape(const std::string& arg);
 void runCommand(const std::string& strCommand);
 #endif
 
-namespace ctpl {
-    class thread_pool;
-}
-void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName);
-
 /**
  * Return the number of cores available on the current system.
  * @note This does count virtual cores, such as those provided by HyperThreading.
diff --git a/src/util/thread.cpp b/src/util/thread.cpp
index e8daf429e8dd..b8359bb90be6 100644
--- a/src/util/thread.cpp
+++ b/src/util/thread.cpp
@@ -4,12 +4,22 @@
 
 #include <util/thread.h>
 
+#include <ctpl_stl.h>
 #include <logging.h>
+#include <tinyformat.h>
 #include <util/exception.h>
 #include <util/threadnames.h>
+#include <util/time.h>
 
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
 #include <exception>
 #include <functional>
+#include <future>
+#include <map>
+#include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 
@@ -25,3 +35,41 @@ void util::TraceThread(std::string_view thread_name, std::function<void()> threa
         throw;
     }
 }
+
+void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName)
+{
+    auto cond = std::make_shared<std::condition_variable>();
+    auto mutex = std::make_shared<std::mutex>();
+    std::atomic<int> doneCnt(0);
+    std::map<int, std::future<void>> futures;
+
+    for (int i = 0; i < tp.size(); i++) {
+        futures[i] = tp.push([baseName, i, cond, mutex, &doneCnt](int threadId) {
+            util::ThreadRename(strprintf("%s-%d", baseName, i));
+            std::unique_lock<std::mutex> l(*mutex);
+            doneCnt++;
+            cond->wait(l);
+        });
+    }
+
+    do {
+        // Always sleep to let all threads acquire locks
+        UninterruptibleSleep(std::chrono::milliseconds{10});
+        // `doneCnt` should be at least `futures.size()` if tp size was increased (for whatever reason),
+        // or at least `tp.size()` if tp size was decreased and queue was cleared
+        // (which can happen on `stop()` if we were not fast enough to get all jobs to their threads).
+    } while (uint64_t(doneCnt) < futures.size() && doneCnt < tp.size());
+
+    cond->notify_all();
+
+    // Make sure no one is left behind, just in case
+    for (auto& pair : futures) {
+        auto& f = pair.second;
+        if (f.valid() && f.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout) {
+            LogPrintf("%s: %s-%d timed out\n", __func__, baseName, pair.first);
+            // Notify everyone again
+            cond->notify_all();
+            break;
+        }
+    }
+}
diff --git a/src/util/thread.h b/src/util/thread.h
index 8a2de84a7f9d..87c612a3286f 100644
--- a/src/util/thread.h
+++ b/src/util/thread.h
@@ -8,6 +8,10 @@
 #include <functional>
 #include <string>
 
+namespace ctpl {
+class thread_pool;
+} // namespace ctpl
+
 namespace util {
 /**
  * A wrapper for do-something-once thread functions.
@@ -16,4 +20,7 @@ void TraceThread(std::string_view thread_name, std::function<void()> thread_func
 
 } // namespace util
 
+/** Give every thread of the pool the name "<baseName>-<n>". */
+void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName);
+
 #endif // BITCOIN_UTIL_THREAD_H

From 77842da98cefde27e2447185e1806aada590a9d9 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:20:40 +0700
Subject: [PATCH 02/12] refactor: write the masternode state diff JSON outside
 the kernel

CDeterministicMNStateDiff::ToJson is RPC output code, yet it lives in evo/dmnstate.cpp, which the kernel library builds, and it checks the -deprecatedrpc=service flag through gArgs. Move it next to CDeterministicMNState::ToJson in evo/core_write.cpp and make the flag check a helper local to that file, which leaves no ArgsManager user in evo/netinfo.cpp or evo/dmnstate.cpp.
---
 src/evo/core_write.cpp | 131 +++++++++++++++++++++++++++++++++++++++++
 src/evo/dmnstate.cpp   | 126 ---------------------------------------
 src/evo/netinfo.cpp    |   7 ---
 src/evo/netinfo.h      |   3 -
 4 files changed, 131 insertions(+), 136 deletions(-)

diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index a5cbe174aee8..9cf595033941 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -14,6 +14,7 @@
 #include <llmq/commitment.h>
 #include <util/std23.h>
 
+#include <common/args.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <netaddress.h>
@@ -22,11 +23,19 @@
 
 #include <univalue.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <string>
 #include <type_traits>
 
 namespace {
+/** Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code */
+bool IsServiceDeprecatedRPCEnabled()
+{
+    const auto args = gArgs.GetArgs("-deprecatedrpc");
+    return std::find(args.begin(), args.end(), "service") != args.end();
+}
+
 template <typename Obj>
 std::string GetDeprecatedServiceField(const Obj& obj)
 {
@@ -191,6 +200,128 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     return obj;
 }
 
+UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
+{
+    UniValue obj(UniValue::VOBJ);
+    if (fields & Field_nVersion) {
+        obj.pushKV("version", state.nVersion);
+    }
+    if (fields & Field_netInfo) {
+        if (IsServiceDeprecatedRPCEnabled()) {
+            obj.pushKV("service", state.netInfo->GetPrimary().ToStringAddrPort());
+        }
+    }
+    if (fields & Field_nRegisteredHeight) {
+        obj.pushKV("registeredHeight", state.nRegisteredHeight);
+    }
+    if (fields & Field_nLastPaidHeight) {
+        obj.pushKV("lastPaidHeight", state.nLastPaidHeight);
+    }
+    if (fields & Field_nConsecutivePayments) {
+        obj.pushKV("consecutivePayments", state.nConsecutivePayments);
+    }
+    if (fields & Field_nPoSePenalty) {
+        obj.pushKV("PoSePenalty", state.nPoSePenalty);
+    }
+    if (fields & Field_nPoSeRevivedHeight) {
+        obj.pushKV("PoSeRevivedHeight", state.nPoSeRevivedHeight);
+    }
+    if (fields & Field_nPoSeBanHeight) {
+        obj.pushKV("PoSeBanHeight", state.nPoSeBanHeight);
+    }
+    if (fields & Field_nRevocationReason) {
+        obj.pushKV("revocationReason", state.nRevocationReason);
+    }
+    if (fields & Field_keyIDOwner) {
+        obj.pushKV("ownerAddress", EncodeDestination(PKHash(state.keyIDOwner)));
+    }
+    if (fields & Field_keyIDVoting) {
+        obj.pushKV("votingAddress", EncodeDestination(PKHash(state.keyIDVoting)));
+    }
+    if (fields & Field_scriptPayout) {
+        CTxDestination dest;
+        if (ExtractDestination(state.scriptPayout, dest)) {
+            obj.pushKV("payoutAddress", EncodeDestination(dest));
+        }
+    }
+    if (fields & Field_payouts) {
+        obj.pushKV("payouts", PayoutListToJson(state.payouts));
+    }
+    if (fields & Field_shares) {
+        obj.pushKV("shares", ShareListToJson(state.shares));
+    }
+    if (fields & Field_nEarlyPeriodBlocks) {
+        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(state.nEarlyPeriodBlocks));
+    }
+    if (fields & Field_nEarlyPenalty) {
+        obj.pushKV("earlyPenalty", state.nEarlyPenalty);
+    }
+    if (fields & Field_scriptOperatorPayout) {
+        CTxDestination dest;
+        if (ExtractDestination(state.scriptOperatorPayout, dest)) {
+            obj.pushKV("operatorPayoutAddress", EncodeDestination(dest));
+        }
+    }
+    if (fields & Field_pubKeyOperator) {
+        obj.pushKV("pubKeyOperator", state.pubKeyOperator.ToString());
+    }
+    if (nType == MnType::Evo) {
+        if (fields & Field_platformNodeID) {
+            obj.pushKV("platformNodeID", state.platformNodeID.ToString());
+        }
+        if (IsServiceDeprecatedRPCEnabled()) {
+            // platformP2PPort/platformHTTPPort are deprecated scalar duplicates of netInfo's
+            // Platform entries. From ExtAddr onwards the scalar fields are unused (always 0), so
+            // when the diff carries an ExtAddr netInfo report the live port from it to stay
+            // consistent with the "addresses" output below.
+            const bool has_ext_netinfo = (fields & Field_netInfo) && state.netInfo->CanStorePlatform();
+            if (fields & Field_platformP2PPort) {
+                obj.pushKV("platformP2PPort", has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)
+                                                  ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort()
+                                                  : state.platformP2PPort);
+            }
+            if (fields & Field_platformHTTPPort) {
+                obj.pushKV("platformHTTPPort", has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS)
+                                                   ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort()
+                                                   : state.platformHTTPPort);
+            }
+        }
+    }
+    {
+        const bool has_netinfo = (fields & Field_netInfo);
+
+        UniValue netInfoObj(UniValue::VOBJ);
+        if (has_netinfo) {
+            netInfoObj = state.netInfo->ToJson();
+        }
+        if (nType == MnType::Evo && (!has_netinfo || !state.netInfo->CanStorePlatform())) {
+            auto unknownAddr = [](uint16_t port) -> UniValue {
+                UniValue obj(UniValue::VARR);
+                // We don't know what the address is because it wasn't changed in the
+                // diff but we still need to report the port number in addr:port format
+                obj.push_back(strprintf("255.255.255.255:%d", port));
+                return obj;
+            };
+            if (fields & Field_platformP2PPort) {
+                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
+                                  (has_netinfo)
+                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformP2PPort))
+                                      : unknownAddr(state.platformP2PPort));
+            }
+            if (fields & Field_platformHTTPPort) {
+                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
+                                  (has_netinfo)
+                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformHTTPPort))
+                                      : unknownAddr(state.platformHTTPPort));
+            }
+        }
+        if (!netInfoObj.empty()) {
+            obj.pushKV("addresses", netInfoObj);
+        }
+    }
+    return obj;
+}
+
 UniValue CProRegTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index 7a8e9da55434..e580456949f0 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -4,9 +4,7 @@
 
 #include <evo/dmnstate.h>
 
-#include <evo/netinfo.h>
 #include <script/standard.h>
-#include <univalue.h>
 
 std::string CDeterministicMNState::ToString() const
 {
@@ -46,127 +44,3 @@ std::vector<CScript> CDeterministicMNState::GetOwnerRewardScripts() const
     }
     return ret;
 }
-
-UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
-{
-    UniValue obj(UniValue::VOBJ);
-    if (fields & Field_nVersion) {
-        obj.pushKV("version", state.nVersion);
-    }
-    if (fields & Field_netInfo) {
-        if (IsServiceDeprecatedRPCEnabled()) {
-            obj.pushKV("service", state.netInfo->GetPrimary().ToStringAddrPort());
-        }
-    }
-    if (fields & Field_nRegisteredHeight) {
-        obj.pushKV("registeredHeight", state.nRegisteredHeight);
-    }
-    if (fields & Field_nLastPaidHeight) {
-        obj.pushKV("lastPaidHeight", state.nLastPaidHeight);
-    }
-    if (fields & Field_nConsecutivePayments) {
-        obj.pushKV("consecutivePayments", state.nConsecutivePayments);
-    }
-    if (fields & Field_nPoSePenalty) {
-        obj.pushKV("PoSePenalty", state.nPoSePenalty);
-    }
-    if (fields & Field_nPoSeRevivedHeight) {
-        obj.pushKV("PoSeRevivedHeight", state.nPoSeRevivedHeight);
-    }
-    if (fields & Field_nPoSeBanHeight) {
-        obj.pushKV("PoSeBanHeight", state.nPoSeBanHeight);
-    }
-    if (fields & Field_nRevocationReason) {
-        obj.pushKV("revocationReason", state.nRevocationReason);
-    }
-    if (fields & Field_keyIDOwner) {
-        obj.pushKV("ownerAddress", EncodeDestination(PKHash(state.keyIDOwner)));
-    }
-    if (fields & Field_keyIDVoting) {
-        obj.pushKV("votingAddress", EncodeDestination(PKHash(state.keyIDVoting)));
-    }
-    if (fields & Field_scriptPayout) {
-        CTxDestination dest;
-        if (ExtractDestination(state.scriptPayout, dest)) {
-            obj.pushKV("payoutAddress", EncodeDestination(dest));
-        }
-    }
-    if (fields & Field_payouts) {
-        obj.pushKV("payouts", PayoutListToJson(state.payouts));
-    }
-    if (fields & Field_shares) {
-        obj.pushKV("shares", ShareListToJson(state.shares));
-    }
-    if (fields & Field_nEarlyPeriodBlocks) {
-        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(state.nEarlyPeriodBlocks));
-    }
-    if (fields & Field_nEarlyPenalty) {
-        obj.pushKV("earlyPenalty", state.nEarlyPenalty);
-    }
-    if (fields & Field_scriptOperatorPayout) {
-        CTxDestination dest;
-        if (ExtractDestination(state.scriptOperatorPayout, dest)) {
-            obj.pushKV("operatorPayoutAddress", EncodeDestination(dest));
-        }
-    }
-    if (fields & Field_pubKeyOperator) {
-        obj.pushKV("pubKeyOperator", state.pubKeyOperator.ToString());
-    }
-    if (nType == MnType::Evo) {
-        if (fields & Field_platformNodeID) {
-            obj.pushKV("platformNodeID", state.platformNodeID.ToString());
-        }
-        if (IsServiceDeprecatedRPCEnabled()) {
-            // platformP2PPort/platformHTTPPort are deprecated scalar duplicates of netInfo's
-            // Platform entries. From ExtAddr onwards the scalar fields are unused (always 0), so
-            // when the diff carries an ExtAddr netInfo report the live port from it to stay
-            // consistent with the "addresses" output below.
-            const bool has_ext_netinfo = (fields & Field_netInfo) && state.netInfo->CanStorePlatform();
-            if (fields & Field_platformP2PPort) {
-                obj.pushKV("platformP2PPort",
-                           has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)
-                               ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort()
-                               : state.platformP2PPort);
-            }
-            if (fields & Field_platformHTTPPort) {
-                obj.pushKV("platformHTTPPort",
-                           has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS)
-                               ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort()
-                               : state.platformHTTPPort);
-            }
-        }
-    }
-    {
-        const bool has_netinfo = (fields & Field_netInfo);
-
-        UniValue netInfoObj(UniValue::VOBJ);
-        if (has_netinfo) {
-            netInfoObj = state.netInfo->ToJson();
-        }
-        if (nType == MnType::Evo && (!has_netinfo || !state.netInfo->CanStorePlatform())) {
-            auto unknownAddr = [](uint16_t port) -> UniValue {
-                UniValue obj(UniValue::VARR);
-                // We don't know what the address is because it wasn't changed in the
-                // diff but we still need to report the port number in addr:port format
-                obj.push_back(strprintf("255.255.255.255:%d", port));
-                return obj;
-            };
-            if (fields & Field_platformP2PPort) {
-                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
-                                  (has_netinfo)
-                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformP2PPort))
-                                      : unknownAddr(state.platformP2PPort));
-            }
-            if (fields & Field_platformHTTPPort) {
-                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
-                                  (has_netinfo)
-                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformHTTPPort))
-                                      : unknownAddr(state.platformHTTPPort));
-            }
-        }
-        if (!netInfoObj.empty()) {
-            obj.pushKV("addresses", netInfoObj);
-        }
-    }
-    return obj;
-}
diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index aa27f5863ff7..67d6c366a0d4 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <common/args.h>
 #include <evo/netinfo.h>
 
 #include <chainparams.h>
@@ -90,12 +89,6 @@ NetInfoStatus ValidateMainnetPrimaryPort(NetInfoPurpose purpose, const NetInfoEn
 
 bool IsNodeOnMainnet() { return Params().GetChainType() == ChainType::MAIN; }
 
-bool IsServiceDeprecatedRPCEnabled()
-{
-    const auto args = gArgs.GetArgs("-deprecatedrpc");
-    return std::find(args.begin(), args.end(), "service") != args.end();
-}
-
 const CChainParams& MainParams()
 {
     std::call_once(g_main_params_flag, [&]() { g_main_params = CreateChainParams(::gArgs, ChainType::MAIN); });
diff --git a/src/evo/netinfo.h b/src/evo/netinfo.h
index adedf33cf9b8..b7e6d594a544 100644
--- a/src/evo/netinfo.h
+++ b/src/evo/netinfo.h
@@ -105,9 +105,6 @@ constexpr std::string_view PurposeToString(const NetInfoPurpose purpose)
 /** Will return true if node is running on mainnet */
 bool IsNodeOnMainnet();
 
-/** Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code */
-bool IsServiceDeprecatedRPCEnabled();
-
 /** Creates a one-element array using CService::ToStringPortAddr() output */
 UniValue ArrFromService(const CService& addr);
 

From 3333b4bcef16ed39c061a31447edc331da23e8cb Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:21:58 +0700
Subject: [PATCH 03/12] refactor: hand CFlatDB its directory instead of reading
 gArgs

CFlatDB resolved its file under gArgs.GetDataDirNet() in its constructor, so every owner (sporks, masternode metadata, governance, net-fulfilled requests) pulled ArgsManager into the kernel library through flat-database.h.
Take the directory as a constructor argument and let the owners pass it in from init, dash-chainstate and the test setup.
---
 src/bitcoin-chainstate.cpp                    |  4 ++--
 src/flat-database.h                           |  5 ++---
 src/governance/governance.cpp                 |  9 +++++----
 src/governance/governance.h                   |  3 ++-
 src/init.cpp                                  | 11 ++++++-----
 src/masternode/meta.cpp                       |  4 ++--
 src/masternode/meta.h                         |  3 ++-
 src/netfulfilledman.cpp                       |  4 ++--
 src/netfulfilledman.h                         |  3 ++-
 src/spork.cpp                                 |  4 ++--
 src/spork.h                                   |  3 ++-
 src/test/governance_inv_tests.cpp             |  5 +++--
 src/test/governance_vote_processing_tests.cpp |  6 +++---
 src/test/governance_vote_sync_tests.cpp       |  2 +-
 src/test/spork_tests.cpp                      |  6 +++---
 src/test/util/setup_common.cpp                |  6 +++---
 16 files changed, 42 insertions(+), 36 deletions(-)

diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index e8dc69795298..9f7795f6c878 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -128,10 +128,10 @@ int main(int argc, char* argv[])
     };
     ChainstateManager chainman{chainman_opts, blockman_opts};
 
-    CMasternodeMetaMan metaman;
+    CMasternodeMetaMan metaman{abs_datadir};
     CEvoDB evodb{util::DbWrapperParams{.path = abs_datadir, .memory = false, .wipe = false}};
     CDeterministicMNManager dmnman{evodb, metaman};
-    CSporkManager sporkman;
+    CSporkManager sporkman{abs_datadir};
     chainlock::Chainlocks chainlocks(sporkman);
 
     auto llmq_ctx = WITH_LOCK(::cs_main, return std::make_unique<LLMQContext>(dmnman, evodb, chainman,
diff --git a/src/flat-database.h b/src/flat-database.h
index d4b32ba300b3..f0fb0209ab72 100644
--- a/src/flat-database.h
+++ b/src/flat-database.h
@@ -7,7 +7,6 @@
 
 #include <clientversion.h>
 #include <chainparams.h>
-#include <common/args.h>
 #include <common/system.h>
 #include <hash.h>
 #include <logging.h>
@@ -178,8 +177,8 @@ class CFlatDB
     }
 
 public:
-    CFlatDB(std::string&& strFilenameIn, std::string&& strMagicMessageIn) :
-        pathDB{gArgs.GetDataDirNet() / fs::u8path(strFilenameIn)},
+    CFlatDB(const fs::path& data_dir, std::string&& strFilenameIn, std::string&& strMagicMessageIn) :
+        pathDB{data_dir / fs::u8path(strFilenameIn)},
         strFilename{strFilenameIn},
         strMagicMessage{strMagicMessageIn}
     {
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index cb75a854a86b..c9559ec039c3 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -73,10 +73,11 @@ GovernanceStore::GovernanceStore() :
 {
 }
 
-CGovernanceManager::CGovernanceManager(CMasternodeMetaMan& mn_metaman, const ChainstateManager& chainman,
-                                       governance::SuperblockManager& superblocks, CDeterministicMNManager& dmnman,
-                                       CMasternodeSync& mn_sync, const governance::CollateralSource* collateral) :
-    m_db{std::make_unique<db_type>("governance.dat", "magicGovernanceCache")},
+CGovernanceManager::CGovernanceManager(const fs::path& data_dir, CMasternodeMetaMan& mn_metaman,
+                                       const ChainstateManager& chainman, governance::SuperblockManager& superblocks,
+                                       CDeterministicMNManager& dmnman, CMasternodeSync& mn_sync,
+                                       const governance::CollateralSource* collateral) :
+    m_db{std::make_unique<db_type>(data_dir, "governance.dat", "magicGovernanceCache")},
     m_mn_metaman{mn_metaman},
     m_chainman{chainman},
     m_superblocks{superblocks},
diff --git a/src/governance/governance.h b/src/governance/governance.h
index 6ae48b209e73..10be5d101e2c 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -11,6 +11,7 @@
 #include <kernel/cs_main.h> // IWYU pragma: export
 #include <primitives/transaction.h>
 #include <sync.h>
+#include <util/fs.h>
 #include <util/time.h>
 
 #include <atomic>
@@ -274,7 +275,7 @@ class CGovernanceManager : public GovernanceStore
     CGovernanceManager() = delete;
     CGovernanceManager(const CGovernanceManager&) = delete;
     CGovernanceManager& operator=(const CGovernanceManager&) = delete;
-    explicit CGovernanceManager(CMasternodeMetaMan& mn_metaman, const ChainstateManager& chainman,
+    explicit CGovernanceManager(const fs::path& data_dir, CMasternodeMetaMan& mn_metaman, const ChainstateManager& chainman,
                                 governance::SuperblockManager& superblocks, CDeterministicMNManager& dmnman,
                                 CMasternodeSync& mn_sync, const governance::CollateralSource* collateral);
     ~CGovernanceManager();
diff --git a/src/init.cpp b/src/init.cpp
index 62d7cc259e6c..61f96c3096bb 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1710,15 +1710,15 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 
     assert(!node.mn_metaman);
-    node.mn_metaman = std::make_unique<CMasternodeMetaMan>();
+    node.mn_metaman = std::make_unique<CMasternodeMetaMan>(args.GetDataDirNet());
 
     assert(!node.netfulfilledman);
-    node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
+    node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(args.GetDataDirNet());
 
     bool is_governance_enabled{!args.GetBoolArg("-disablegovernance", !DEFAULT_GOVERNANCE_ENABLE)};
 
     assert(!node.sporkman);
-    node.sporkman = std::make_unique<CSporkManager>();
+    node.sporkman = std::make_unique<CSporkManager>(args.GetDataDirNet());
     node.chainlocks = std::make_unique<chainlock::Chainlocks>(*node.sporkman);
     node.sbman = std::make_unique<governance::SuperblockManager>();
 
@@ -2173,8 +2173,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 
     assert(!node.govman);
-    node.govman = std::make_unique<CGovernanceManager>(*node.mn_metaman, *node.chainman, *node.sbman, *node.dmnman,
-                                                       *node.mn_sync, node.gov_collateral_index.get());
+    node.govman = std::make_unique<CGovernanceManager>(args.GetDataDirNet(), *node.mn_metaman, *node.chainman,
+                                                       *node.sbman, *node.dmnman, *node.mn_sync,
+                                                       node.gov_collateral_index.get());
 
     // ********************************************************* Step 7c: Setup masternode mode or watch-only mode
     assert(!node.active_ctx);
diff --git a/src/masternode/meta.cpp b/src/masternode/meta.cpp
index c9c3934c4d4a..c995ac8e718f 100644
--- a/src/masternode/meta.cpp
+++ b/src/masternode/meta.cpp
@@ -18,8 +18,8 @@ namespace {
 static const CMasternodeMetaInfo default_meta_info{};
 } // anonymous namespace
 
-CMasternodeMetaMan::CMasternodeMetaMan() :
-    m_db{std::make_unique<db_type>("mncache.dat", "magicMasternodeCache")}
+CMasternodeMetaMan::CMasternodeMetaMan(const fs::path& data_dir) :
+    m_db{std::make_unique<db_type>(data_dir, "mncache.dat", "magicMasternodeCache")}
 {
 }
 
diff --git a/src/masternode/meta.h b/src/masternode/meta.h
index 535a721e586f..3301e4740299 100644
--- a/src/masternode/meta.h
+++ b/src/masternode/meta.h
@@ -12,6 +12,7 @@
 #include <threadsafety.h>
 #include <uint256.h>
 #include <unordered_lru_cache.h>
+#include <util/fs.h>
 
 #include <deque>
 #include <map>
@@ -205,7 +206,7 @@ class CMasternodeMetaMan : public MasternodeMetaStore
 public:
     CMasternodeMetaMan(const CMasternodeMetaMan&) = delete;
     CMasternodeMetaMan& operator=(const CMasternodeMetaMan&) = delete;
-    CMasternodeMetaMan();
+    explicit CMasternodeMetaMan(const fs::path& data_dir);
     ~CMasternodeMetaMan();
 
     bool LoadCache(bool load_cache);
diff --git a/src/netfulfilledman.cpp b/src/netfulfilledman.cpp
index 43b981405911..e4f1c6ee180f 100644
--- a/src/netfulfilledman.cpp
+++ b/src/netfulfilledman.cpp
@@ -7,8 +7,8 @@
 #include <netfulfilledman.h>
 #include <shutdown.h>
 
-CNetFulfilledRequestManager::CNetFulfilledRequestManager() :
-    m_db{std::make_unique<db_type>("netfulfilled.dat", "magicFulfilledCache")}
+CNetFulfilledRequestManager::CNetFulfilledRequestManager(const fs::path& data_dir) :
+    m_db{std::make_unique<db_type>(data_dir, "netfulfilled.dat", "magicFulfilledCache")}
 {
 }
 
diff --git a/src/netfulfilledman.h b/src/netfulfilledman.h
index e8e9b98994c4..2cd60af7cf6a 100644
--- a/src/netfulfilledman.h
+++ b/src/netfulfilledman.h
@@ -8,6 +8,7 @@
 #include <netaddress.h>
 #include <serialize.h>
 #include <sync.h>
+#include <util/fs.h>
 
 #include <memory>
 
@@ -52,7 +53,7 @@ class CNetFulfilledRequestManager : public NetFulfilledRequestStore
 public:
     CNetFulfilledRequestManager(const CNetFulfilledRequestManager&) = delete;
     CNetFulfilledRequestManager& operator=(const CNetFulfilledRequestManager&) = delete;
-    CNetFulfilledRequestManager();
+    explicit CNetFulfilledRequestManager(const fs::path& data_dir);
     ~CNetFulfilledRequestManager();
 
     bool LoadCache(bool load_cache);
diff --git a/src/spork.cpp b/src/spork.cpp
index 0559972311de..8357933d4e08 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -37,8 +37,8 @@ void SporkStore::Clear()
     // we should not alter them here.
 }
 
-CSporkManager::CSporkManager() :
-    m_db{std::make_unique<db_type>("sporks.dat", "magicSporkCache")}
+CSporkManager::CSporkManager(const fs::path& data_dir) :
+    m_db{std::make_unique<db_type>(data_dir, "sporks.dat", "magicSporkCache")}
 {
 }
 
diff --git a/src/spork.h b/src/spork.h
index fef50b497cc1..5d02cd0e4ec2 100644
--- a/src/spork.h
+++ b/src/spork.h
@@ -10,6 +10,7 @@
 #include <pubkey.h>
 #include <saltedhasher.h>
 #include <sync.h>
+#include <util/fs.h>
 #include <util/time.h>
 
 #include <array>
@@ -203,7 +204,7 @@ class CSporkManager : public SporkStore
 public:
     CSporkManager(const CSporkManager&) = delete;
     CSporkManager& operator=(const CSporkManager&) = delete;
-    CSporkManager();
+    explicit CSporkManager(const fs::path& data_dir);
     ~CSporkManager();
 
     bool LoadCache();
diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index f1b21d04775f..d65925d737a7 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -60,8 +60,9 @@ struct GovernanceInvSetup : public TestingSetup {
         // Note: mn_metaman is left unloaded. Reaching CGovernanceObject::ProcessVote asserts
         // metaman.IsValid(), so a test that delivers a vote whose parent object exists must
         // load it first (see invalid_vote_is_scored_alike_with_and_without_a_parent_object).
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.sbman,
-                                                             *m_node.dmnman, *m_node.mn_sync, &m_collateral);
+        m_node.govman = std::make_unique<CGovernanceManager>(m_args.GetDataDirNet(), *m_node.mn_metaman,
+                                                             *m_node.chainman, *m_node.sbman, *m_node.dmnman,
+                                                             *m_node.mn_sync, &m_collateral);
         // Match runtime preconditions: NetGovernance::AlreadyHave claims we
         // already have the inv when governance isn't loaded (e.g.
         // -disablegovernance), so ConfirmInventoryRequest would never run.
diff --git a/src/test/governance_vote_processing_tests.cpp b/src/test/governance_vote_processing_tests.cpp
index 171c0708be78..2b2f6f28bfb3 100644
--- a/src/test/governance_vote_processing_tests.cpp
+++ b/src/test/governance_vote_processing_tests.cpp
@@ -132,9 +132,9 @@ struct GovernanceVoteSetup : public TestChainSetup {
         }
         BOOST_REQUIRE(m_node.mn_sync->IsSynced());
 
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.sbman,
-                                                             *m_node.dmnman, *m_node.mn_sync,
-                                                             m_node.gov_collateral_index.get());
+        m_node.govman = std::make_unique<CGovernanceManager>(m_args.GetDataDirNet(), *m_node.mn_metaman,
+                                                             *m_node.chainman, *m_node.sbman, *m_node.dmnman,
+                                                             *m_node.mn_sync, m_node.gov_collateral_index.get());
         BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
 
         proposal_time = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
diff --git a/src/test/governance_vote_sync_tests.cpp b/src/test/governance_vote_sync_tests.cpp
index 3729efc24f7f..d0dc8f641130 100644
--- a/src/test/governance_vote_sync_tests.cpp
+++ b/src/test/governance_vote_sync_tests.cpp
@@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(fulfilled_request_manager_is_port_sensitive)
     const CService peer_a{CNetAddr{ipv4}, /*port=*/40000};
     const CService peer_b{CNetAddr{ipv4}, /*port=*/40001};
 
-    CNetFulfilledRequestManager fulfilled;
+    CNetFulfilledRequestManager fulfilled{m_args.GetDataDirNet()};
     BOOST_REQUIRE(fulfilled.LoadCache(/*load_cache=*/false));
 
     const std::string request{"mngovernancesync-votes-deadbeef"};
diff --git a/src/test/spork_tests.cpp b/src/test/spork_tests.cpp
index 94f9cebe5c93..e2ca5b12e32a 100644
--- a/src/test/spork_tests.cpp
+++ b/src/test/spork_tests.cpp
@@ -19,7 +19,7 @@ BOOST_FIXTURE_TEST_SUITE(spork_tests, RegTestingSetup)
 
 BOOST_AUTO_TEST_CASE(extreme_timestamps_are_handled_without_overflow)
 {
-    CSporkManager sporkman;
+    CSporkManager sporkman{m_args.GetDataDirNet()};
     CKey key;
     key.MakeNewKey(/*fCompressed=*/true);
     BOOST_REQUIRE(sporkman.SetSporkAddress(EncodeDestination(PKHash{key.GetPubKey()})));
@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(extreme_timestamps_are_handled_without_overflow)
 
 BOOST_AUTO_TEST_CASE(sporks_signed_by_an_unknown_key_are_rejected)
 {
-    CSporkManager sporkman;
+    CSporkManager sporkman{m_args.GetDataDirNet()};
     CKey spork_key;
     spork_key.MakeNewKey(/*fCompressed=*/true);
     BOOST_REQUIRE(sporkman.SetSporkAddress(EncodeDestination(PKHash{spork_key.GetPubKey()})));
@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(sporks_signed_by_an_unknown_key_are_rejected)
 
 BOOST_AUTO_TEST_CASE(check_and_remove_drops_sporks_not_signed_by_the_spork_key)
 {
-    CSporkManager sporkman;
+    CSporkManager sporkman{m_args.GetDataDirNet()};
     CKey key;
     key.MakeNewKey(/*fCompressed=*/true);
     BOOST_REQUIRE(sporkman.SetSporkAddress(EncodeDestination(PKHash{key.GetPubKey()})));
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index d50805fabf68..54cf417a1637 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -217,9 +217,9 @@ BasicTestingSetup::BasicTestingSetup(const ChainType chainType, const std::vecto
 
     m_node.connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman); // Deterministic randomness for tests.
 
-    m_node.mn_metaman = std::make_unique<CMasternodeMetaMan>();
-    m_node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
-    m_node.sporkman = std::make_unique<CSporkManager>();
+    m_node.mn_metaman = std::make_unique<CMasternodeMetaMan>(m_args.GetDataDirNet());
+    m_node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(m_args.GetDataDirNet());
+    m_node.sporkman = std::make_unique<CSporkManager>(m_args.GetDataDirNet());
     m_node.chainlocks = std::make_unique<chainlock::Chainlocks>(*m_node.sporkman);
     m_node.sbman = std::make_unique<governance::SuperblockManager>();
     m_node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*m_node.connman, *m_node.netfulfilledman));

From b0a6938e955103c8b22a276fd3704897fec4f739 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:26:45 +0700
Subject: [PATCH 04/12] refactor: pass the time adjustment limit into
 AddTimeData

AddTimeData read -maxtimeadjustment through gArgs, and timedata.cpp has to stay in the kernel library because spork.cpp uses GetAdjustedTime. Make the limit a PeerManager option filled by node/peerman_args.cpp and hand it to AddTimeData from the only production caller, so timedata.cpp needs no ArgsManager.
---
 src/net_processing.cpp      | 2 +-
 src/net_processing.h        | 3 +++
 src/node/peerman_args.cpp   | 2 ++
 src/test/timedata_tests.cpp | 2 +-
 src/timedata.cpp            | 5 ++---
 src/timedata.h              | 2 +-
 6 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 10ae4ebe2874..b285de58a8d6 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -4249,7 +4249,7 @@ void PeerManagerImpl::ProcessMessage(
         if (!pfrom.IsInboundConn()) {
             // Don't use timedata samples from inbound peers to make it
             // harder for others to tamper with our adjusted time.
-            AddTimeData(pfrom.addr, nTimeOffset);
+            AddTimeData(pfrom.addr, nTimeOffset, m_opts.max_time_adjustment);
         }
 
         // Feeler connections exist only to verify if address is online.
diff --git a/src/net_processing.h b/src/net_processing.h
index d83a30d0f493..5f4bc83c80ed 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -7,6 +7,7 @@
 #define BITCOIN_NET_PROCESSING_H
 
 #include <net.h>
+#include <timedata.h>
 #include <validationinterface.h>
 #include <version.h>
 
@@ -174,6 +175,8 @@ class PeerManager : public CValidationInterface, public NetEventsInterface, publ
         //! Whether or not the internal RNG behaves deterministically (this is
         //! a test-only option).
         bool deterministic_rng{false};
+        //! Maximum allowed median peer time offset adjustment, in seconds
+        int64_t max_time_adjustment{DEFAULT_MAX_TIME_ADJUSTMENT};
     };
 
     /**
diff --git a/src/node/peerman_args.cpp b/src/node/peerman_args.cpp
index 205507dcb385..c3cdbcc44b06 100644
--- a/src/node/peerman_args.cpp
+++ b/src/node/peerman_args.cpp
@@ -21,6 +21,8 @@ void ApplyArgsManOptions(const ArgsManager& argsman, PeerManager::Options& optio
     }
 
     if (auto value{argsman.GetBoolArg("-capturemessages")}) options.capture_messages = *value;
+
+    if (auto value{argsman.GetIntArg("-maxtimeadjustment")}) options.max_time_adjustment = *value;
 }
 
 } // namespace node
diff --git a/src/test/timedata_tests.cpp b/src/test/timedata_tests.cpp
index 2814dbf4c06a..d8063c45002c 100644
--- a/src/test/timedata_tests.cpp
+++ b/src/test/timedata_tests.cpp
@@ -49,7 +49,7 @@ static void MultiAddTimeData(int n, int64_t offset)
     for (int i = 0; i < n; ++i) {
         CNetAddr addr;
         addr.SetInternal(ToString(++cnt));
-        AddTimeData(addr, offset);
+        AddTimeData(addr, offset, DEFAULT_MAX_TIME_ADJUSTMENT);
     }
 }
 
diff --git a/src/timedata.cpp b/src/timedata.cpp
index 15ca90ee6a05..7453818420b2 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -8,7 +8,6 @@
 
 #include <timedata.h>
 
-#include <common/args.h>
 #include <logging.h>
 #include <netaddress.h>
 #include <node/interface_ui.h>
@@ -44,7 +43,7 @@ static std::set<CNetAddr> g_sources;
 static CMedianFilter<int64_t> g_time_offsets{BITCOIN_TIMEDATA_MAX_SAMPLES, 0};
 static bool g_warning_emitted;
 
-void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)
+void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample, int64_t max_adjustment)
 {
     LOCK(g_timeoffset_mutex);
     // Ignore duplicates
@@ -78,7 +77,7 @@ void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)
         int64_t nMedian = g_time_offsets.median();
         std::vector<int64_t> vSorted = g_time_offsets.sorted();
         // Only let other nodes change our time by so much
-        int64_t max_adjustment = std::max<int64_t>(0, gArgs.GetIntArg("-maxtimeadjustment", DEFAULT_MAX_TIME_ADJUSTMENT));
+        max_adjustment = std::max<int64_t>(0, max_adjustment);
         if (nMedian >= -max_adjustment && nMedian <= max_adjustment) {
             nTimeOffset = nMedian;
         } else {
diff --git a/src/timedata.h b/src/timedata.h
index c6c36d9a3970..9f52d8d4d01b 100644
--- a/src/timedata.h
+++ b/src/timedata.h
@@ -76,7 +76,7 @@ class CMedianFilter
 /** Functions to keep track of adjusted P2P time */
 int64_t GetTimeOffset();
 NodeClock::time_point GetAdjustedTime();
-void AddTimeData(const CNetAddr& ip, int64_t nTime);
+void AddTimeData(const CNetAddr& ip, int64_t nTime, int64_t max_adjustment);
 
 /**
  * Reset the internal state of GetTimeOffset(), GetAdjustedTime() and AddTimeData().

From 87f6327937c4eb90684b2e8951475d709a688952 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:31:24 +0700
Subject: [PATCH 05/12] refactor: drive the legacy index migration from
 ChainstateLoadOptions

CBlockTreeDB::MigrateOldIndexData read the index flags, -dbbatchsize and the datadir through gArgs, which kept ArgsManager inside the kernel library via txdb.cpp.
Collect those values in an IndexMigrationOptions filled by init and the test setup, carry them in ChainstateLoadOptions next to data_dir, and run the migration from LoadChainstate right after the block index is loaded, where it used to run at the end of BlockManager::LoadBlockIndexDB.
---
 src/init.cpp                       |  4 ++++
 src/node/blockstorage.cpp          |  6 ------
 src/node/chainstate.cpp            |  6 ++++++
 src/node/chainstate.h              |  1 +
 src/test/index_migration_tests.cpp |  3 ++-
 src/test/util/setup_common.cpp     |  6 ++++++
 src/txdb.cpp                       | 18 ++++++++----------
 src/txdb.h                         | 10 +++++++++-
 8 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 61f96c3096bb..61568049c741 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -2062,6 +2062,10 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         node::ChainstateLoadOptions options;
         options.chainlocks = Assert(node.chainlocks.get());
         options.data_dir = args.GetDataDirNet();
+        options.index_migration.address_index = args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
+        options.index_migration.spent_index = args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
+        options.index_migration.timestamp_index = args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
+        options.index_migration.batch_size = args.GetIntArg("-dbbatchsize", nDefaultDbBatchSize);
         options.reindex = node::fReindex;
         options.reindex_chainstate = fReindexChainState;
         options.prune = chainman.m_blockman.IsPruneMode();
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 5bb1e99fe34c..f22bc434209f 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -398,12 +398,6 @@ bool BlockManager::LoadBlockIndexDB()
     m_block_tree_db->ReadReindexing(fReindexing);
     if (fReindexing) fReindex = true;
 
-    // Migrate old synchronous index data from block index database
-    // to async indexes in separate databases
-    if (!m_block_tree_db->MigrateOldIndexData()) {
-        return false;
-    }
-
     return true;
 }
 
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index ea001791d571..302f17efc32d 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -174,6 +174,12 @@ static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager&
         return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
     }
 
+    // Migrate old synchronous index data from block index database
+    // to async indexes in separate databases
+    if (!options.reindex && !chainman.m_blockman.m_block_tree_db->MigrateOldIndexData(options.data_dir, options.index_migration)) {
+        return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
+    }
+
     if (!chainman.BlockIndex().empty() &&
             !chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
         // If the loaded chain has a wrong genesis, bail out immediately
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
index 1a5b63b03a28..5255711ffdc8 100644
--- a/src/node/chainstate.h
+++ b/src/node/chainstate.h
@@ -33,6 +33,7 @@ struct ChainstateLoadOptions {
     llmq::CInstantSendManager* isman{nullptr};
     chainlock::Chainlocks* chainlocks{nullptr};
     fs::path data_dir;
+    IndexMigrationOptions index_migration;
 
     bool block_tree_db_in_memory{false};
     bool coins_db_in_memory{false};
diff --git a/src/test/index_migration_tests.cpp b/src/test/index_migration_tests.cpp
index bcf9250b50d5..09675d8277c3 100644
--- a/src/test/index_migration_tests.cpp
+++ b/src/test/index_migration_tests.cpp
@@ -57,7 +57,8 @@ BOOST_FIXTURE_TEST_CASE(empty_index_is_not_adopted_as_migrated, IndexMigrationSe
     CBlockTreeDB& block_tree_db{*WITH_LOCK(cs_main, return m_node.chainman->m_blockman.m_block_tree_db.get())};
     BOOST_REQUIRE(block_tree_db.WriteFlag("timestampindex", true));
 
-    BOOST_REQUIRE(WITH_LOCK(cs_main, return block_tree_db.MigrateOldIndexData()));
+    BOOST_REQUIRE(
+        WITH_LOCK(cs_main, return block_tree_db.MigrateOldIndexData(gArgs.GetDataDirNet(), {.timestamp_index = true})));
 
     BOOST_CHECK_EQUAL(LoadedTimestampIndexHeight(), 0);
     // The legacy entries are gone, so older versions must not trust their synchronous index either.
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 54cf417a1637..f8cfedbbc909 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -23,6 +23,9 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <crypto/sha256.h>
+#include <index/addressindex.h>
+#include <index/spentindex.h>
+#include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <init.h>
 #include <init/common.h>
@@ -323,6 +326,9 @@ node::ChainstateLoadOptions ChainTestingSetup::ChainstateLoadOptionsForTest()
     options.isman = Assert(m_node.isman.get());
     options.chainlocks = Assert(m_node.chainlocks.get());
     options.data_dir = Assert(m_node.args)->GetDataDirNet();
+    options.index_migration.address_index = Assert(m_node.args)->GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
+    options.index_migration.spent_index = Assert(m_node.args)->GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
+    options.index_migration.timestamp_index = Assert(m_node.args)->GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
     options.block_tree_db_in_memory = m_block_tree_db_in_memory;
     options.coins_db_in_memory = m_coins_db_in_memory;
     options.dash_dbs_in_memory = m_dash_dbs_in_memory;
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 0a2a6b1a7edc..855f4ee00e75 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -7,7 +7,6 @@
 #include <txdb.h>
 
 #include <chain.h>
-#include <common/args.h>
 #include <index/addressindex_types.h>
 #include <index/spentindex_types.h>
 #include <index/timestampindex_types.h>
@@ -488,18 +487,17 @@ static bool TargetNeedsLocator(CDBWrapper& target_db)
     return !target_db.IsEmpty();
 }
 
-bool CBlockTreeDB::MigrateOldIndexData()
+bool CBlockTreeDB::MigrateOldIndexData(const fs::path& data_dir, const IndexMigrationOptions& options)
 {
     // Migrate old synchronous index data that was stored in the block index database
     // to new async indexes in separate databases under indexes/{timestampindex,spentindex,addressindex}/
     // This preserves existing index data so users don't need to rebuild.
     // Indexes are migrated independently since they can be enabled individually.
 
-    // Only migrate indexes that are actually enabled via command-line flags
-    // NOTE: not using DEFAULT_* constants here to avoid circular dependencies
-    const bool fTimestampIndex = gArgs.GetBoolArg("-timestampindex", false);
-    const bool fSpentIndex = gArgs.GetBoolArg("-spentindex", false);
-    const bool fAddressIndex = gArgs.GetBoolArg("-addressindex", false);
+    // Only migrate indexes that are actually enabled
+    const bool fTimestampIndex = options.timestamp_index;
+    const bool fSpentIndex = options.spent_index;
+    const bool fAddressIndex = options.address_index;
 
     // The flags read below say whether the legacy rows still cover the chain tip. Nothing
     // maintains those rows any more, so a disabled index falls behind from this run on:
@@ -532,15 +530,15 @@ bool CBlockTreeDB::MigrateOldIndexData()
     const bool spentindex_was_current     = ReadFlag("spentindex",     legacy_flag) && legacy_flag;
     const bool timestampindex_was_current = ReadFlag("timestampindex", legacy_flag) && legacy_flag;
 
-    size_t batch_size = (size_t)gArgs.GetIntArg("-dbbatchsize", nDefaultDbBatchSize);
+    const size_t batch_size = options.batch_size;
     size_t total_count = 0;
-    const fs::path indexes_path = gArgs.GetDataDirNet() / "indexes";
+    const fs::path indexes_path = data_dir / "indexes";
 
     // Read the best block hash from coins database to set as best block for migrated indexes
     // Old synchronous indexes were updated during ConnectBlock, so they're synced to the active chain tip
     uint256 best_block_hash;
     {
-        fs::path chainstate_path = gArgs.GetDataDirNet() / "chainstate";
+        fs::path chainstate_path = data_dir / "chainstate";
         CDBWrapper coins_db{DBParams{.path = chainstate_path, .cache_bytes = 0}};
         if (!coins_db.Read(DB_BEST_BLOCK, best_block_hash)) {
             // If we can't read the best block, the indexes will resync from scratch
diff --git a/src/txdb.h b/src/txdb.h
index b4ea64a07147..cbe025066bdc 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -31,6 +31,14 @@ struct bilingual_str;
 static const int64_t nDefaultDbCache = 300;
 //! -dbbatchsize default (bytes)
 static const int64_t nDefaultDbBatchSize = 16 << 20;
+
+//! Which legacy synchronous indexes CBlockTreeDB::MigrateOldIndexData() carries over
+struct IndexMigrationOptions {
+    bool address_index{false};
+    bool spent_index{false};
+    bool timestamp_index{false};
+    size_t batch_size{nDefaultDbBatchSize};
+};
 //! max. -dbcache (MiB)
 static const int64_t nMaxDbCache = sizeof(void*) > 4 ? 16384 : 1024;
 //! min. -dbcache (MiB)
@@ -101,7 +109,7 @@ class CBlockTreeDB : public CDBWrapper
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /// Migrate old synchronous index data to new async index databases
-    bool MigrateOldIndexData() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    bool MigrateOldIndexData(const fs::path& data_dir, const IndexMigrationOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
 #endif // BITCOIN_TXDB_H

From f5c04d085edcae3332eb9a7f838fd4fe6db44be9 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:36:32 +0700
Subject: [PATCH 06/12] refactor: resolve the InstantSend double-spend conflict
 outside validation

MemPoolAccept looked up the transaction an InstantSend lock conflicts with through node::GetTransaction, which pulled node/transaction.cpp, the txindex and node/database_args.cpp into the kernel library only to publish a zmq notification. Let the signal carry the conflicting txid and resolve the transaction in CZMQNotificationInterface through a lookup handed in from init, like the block lookup bitcoin#27125 introduced.
The notification is still skipped when the transaction cannot be found, so the published messages do not change.
---
 src/init.cpp                         |  6 ++++++
 src/validation.cpp                   | 11 +----------
 src/validationinterface.cpp          |  8 ++++----
 src/validationinterface.h            |  5 +++--
 src/zmq/zmqnotificationinterface.cpp | 12 ++++++++----
 src/zmq/zmqnotificationinterface.h   |  6 ++++--
 6 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 61568049c741..9a695c2bb959 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -65,6 +65,7 @@
 #include <node/mempool_persist_args.h>
 #include <node/miner.h>
 #include <node/peerman_args.h>
+#include <node/transaction.h>
 #include <node/sync_manager.h>
 #include <node/validation_cache_args.h>
 #include <policy/feerate.h>
@@ -1951,6 +1952,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         [&chainman = node.chainman](CBlock& block, const CBlockIndex& index) {
             assert(chainman);
             return chainman->m_blockman.ReadBlockFromDisk(block, index);
+        },
+        [&chainman = node.chainman, &mempool = node.mempool](const uint256& txid) {
+            assert(chainman);
+            uint256 block_hash;
+            return node::GetTransaction(/*block_index=*/nullptr, mempool.get(), txid, block_hash, chainman->m_blockman);
         });
 
     if (g_zmq_notification_interface) {
diff --git a/src/validation.cpp b/src/validation.cpp
index f63a3ad06684..f4b3c9a7100c 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -127,12 +127,6 @@ GlobalMutex g_best_block_mutex;
 std::condition_variable g_best_block_cv;
 uint256 g_best_block;
 
-// Forward declaration to break dependency over node/transaction.h
-namespace node
-{
-CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
-} // namespace node
-using node::GetTransaction;
 
 namespace {
 
@@ -904,10 +898,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     if (auto conflictLockOpt = m_isman ? m_isman->ConflictingISLockIfAny(tx) : std::nullopt; conflictLockOpt.has_value()) {
         auto& [_, conflict_txid] = conflictLockOpt.value();
 
-        uint256 hashBlock;
-        if (auto txConflict = GetTransaction(nullptr, &m_pool, conflict_txid, hashBlock, m_active_chainstate.m_blockman); txConflict) {
-            GetMainSignals().NotifyInstantSendDoubleSpendAttempt(ptx, txConflict);
-        }
+        GetMainSignals().NotifyInstantSendDoubleSpendAttempt(ptx, m_pool.get(conflict_txid), conflict_txid);
         LogPrintf("ERROR: AcceptToMemoryPool : Transaction %s conflicts with locked TX %s\n", hash.ToString(), conflict_txid.ToString());
         return state.Invalid(TxValidationResult::TX_CONFLICT_LOCK, "tx-txlock-conflict");
     }
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
index 3b7bf4528c75..bbb4328470e9 100644
--- a/src/validationinterface.cpp
+++ b/src/validationinterface.cpp
@@ -307,13 +307,13 @@ void CMainSignals::NotifyGovernanceObject(const std::shared_ptr<const Governance
     ENQUEUE_AND_LOG_EVENT(event, "%s: notify governance object: %s", __func__, id);
 }
 
-void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) {
-    auto event = [currentTx, previousTx, this] {
-        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx); });
+void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid) {
+    auto event = [currentTx, previousTx, previous_txid, this] {
+        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx, previous_txid); });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: notify instant doublespendattempt currenttxid=%s previoustxid=%s", __func__,
             currentTx->GetHash().ToString(),
-            previousTx->GetHash().ToString());
+            previous_txid.ToString());
 }
 
 void CMainSignals::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, const std::string& id, bool proactive_relay) {
diff --git a/src/validationinterface.h b/src/validationinterface.h
index 953149c3b263..10a586ffa6ba 100644
--- a/src/validationinterface.h
+++ b/src/validationinterface.h
@@ -179,7 +179,8 @@ class CValidationInterface {
     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) {}
+    /** previousTx is the conflicting transaction if the mempool had it when the attempt was detected, nullptr otherwise. */
+    virtual void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid) {}
     virtual void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay) {}
     virtual void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) {}
     /**
@@ -248,7 +249,7 @@ class CMainSignals {
     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);
+    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid);
     void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig, const std::string& id, bool proactive_relay);
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff);
     void ChainStateFlushed(const CBlockLocator &);
diff --git a/src/zmq/zmqnotificationinterface.cpp b/src/zmq/zmqnotificationinterface.cpp
index 8dcfc4986d44..3111abd8b3b4 100644
--- a/src/zmq/zmqnotificationinterface.cpp
+++ b/src/zmq/zmqnotificationinterface.cpp
@@ -40,7 +40,8 @@ std::list<const CZMQAbstractNotifier*> CZMQNotificationInterface::GetActiveNotif
     return result;
 }
 
-std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index)
+std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index,
+                                                                             std::function<CTransactionRef(const uint256&)> get_transaction)
 {
     std::map<std::string, CZMQNotifierFactory> factories;
     factories["pubhashblock"] = CZMQAbstractNotifier::Create<CZMQPublishHashBlockNotifier>;
@@ -92,6 +93,7 @@ std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std
     {
         std::unique_ptr<CZMQNotificationInterface> notificationInterface(new CZMQNotificationInterface());
         notificationInterface->notifiers = std::move(notifiers);
+        notificationInterface->m_get_transaction = std::move(get_transaction);
 
         if (notificationInterface->Initialize()) {
             return notificationInterface;
@@ -250,10 +252,12 @@ void CZMQNotificationInterface::NotifyGovernanceObject(const std::shared_ptr<con
     });
 }
 
-void CZMQNotificationInterface::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx)
+void CZMQNotificationInterface::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid)
 {
-    TryForEachAndRemoveFailed(notifiers, [&currentTx, &previousTx](CZMQAbstractNotifier* notifier) {
-        return notifier->NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx);
+    const CTransactionRef conflictTx{previousTx ? previousTx : m_get_transaction(previous_txid)};
+    if (!conflictTx) return;
+    TryForEachAndRemoveFailed(notifiers, [&currentTx, &conflictTx](CZMQAbstractNotifier* notifier) {
+        return notifier->NotifyInstantSendDoubleSpendAttempt(currentTx, conflictTx);
     });
 }
 
diff --git a/src/zmq/zmqnotificationinterface.h b/src/zmq/zmqnotificationinterface.h
index 8858dfc00349..fdae9f6160f6 100644
--- a/src/zmq/zmqnotificationinterface.h
+++ b/src/zmq/zmqnotificationinterface.h
@@ -24,7 +24,8 @@ class CZMQNotificationInterface final : public CValidationInterface
 
     std::list<const CZMQAbstractNotifier*> GetActiveNotifiers() const;
 
-    static std::unique_ptr<CZMQNotificationInterface> Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index);
+    static std::unique_ptr<CZMQNotificationInterface> Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index,
+                                                             std::function<CTransactionRef(const uint256&)> get_transaction);
 
 protected:
     bool Initialize();
@@ -40,7 +41,7 @@ class CZMQNotificationInterface final : public CValidationInterface
     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;
-    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) override;
+    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid) override;
     void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool /*proactive_relay*/) override;
 
 private:
@@ -48,6 +49,7 @@ class CZMQNotificationInterface final : public CValidationInterface
 
     void* pcontext{nullptr};
     std::list<std::unique_ptr<CZMQAbstractNotifier>> notifiers;
+    std::function<CTransactionRef(const uint256&)> m_get_transaction;
 };
 
 extern std::unique_ptr<CZMQNotificationInterface> g_zmq_notification_interface;

From 5c424731bd7e5897e0f23d79091bd5728872a7b2 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Thu, 5 Nov 2026 02:46:26 +0700
Subject: [PATCH 07/12] refactor: build netinfo's mainnet params without
 ArgsManager

MainParams() exists to validate addresses against mainnet rules regardless of the selected network, but it built them through CreateChainParams(gArgs, MAIN), pulling the kernel's evo code into ArgsManager although mainnet params take no options.
Use CChainParams::Main() directly; common/system.h was only included for gArgs.
---
 src/evo/netinfo.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index 67d6c366a0d4..fea370c5403b 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -5,7 +5,6 @@
 #include <evo/netinfo.h>
 
 #include <chainparams.h>
-#include <common/system.h>
 #include <evo/types.h>
 #include <netbase.h>
 #include <span.h>
@@ -91,7 +90,7 @@ bool IsNodeOnMainnet() { return Params().GetChainType() == ChainType::MAIN; }
 
 const CChainParams& MainParams()
 {
-    std::call_once(g_main_params_flag, [&]() { g_main_params = CreateChainParams(::gArgs, ChainType::MAIN); });
+    std::call_once(g_main_params_flag, [&]() { g_main_params = CChainParams::Main(); });
     return *Assert(g_main_params);
 }
 

From 0491714e321e850a964d8641fcbce9458c6fcc61 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Thu, 5 Nov 2026 02:47:12 +0700
Subject: [PATCH 08/12] refactor: read chain params from the owning manager in
 llmq and mnhf

CQuorumBlockProcessor, CQuorumManager, CDKGSessionManager and CMNHFManager already hold the ChainstateManager or consensus params they were built for, yet still read the process-wide Params() global, whose definition in chainparams.cpp keeps ArgsManager in the kernel library.
---
 src/evo/mnhftx.cpp          |  2 +-
 src/llmq/blockprocessor.cpp | 18 +++++++++---------
 src/llmq/dkgsessionmgr.cpp  |  5 ++---
 src/llmq/quorumsman.cpp     |  6 +++---
 4 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
index 1a2555cd3628..f17b520c1189 100644
--- a/src/evo/mnhftx.cpp
+++ b/src/evo/mnhftx.cpp
@@ -75,7 +75,7 @@ CMNHFManager::Signals CMNHFManager::GetSignalsStage(const CBlockIndex* const pin
         assert(signal_pindex != nullptr);
         const int64_t signal_time = signal_pindex->GetMedianTimePast();
         for (int index = 0; index < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++index) {
-            const auto& deployment = Params().GetConsensus().vDeployments[index];
+            const auto& deployment = m_consensus_params.vDeployments[index];
             if (deployment.bit != signal.first) continue;
             if (signal_time < deployment.nStartTime) {
                 // new deployment is using the same bit as the old one
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index f8442e093ab4..5f140c474216 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -127,7 +127,7 @@ MessageProcessingResult CQuorumBlockProcessor::ProcessMessage(const CNode& peer,
         return ret;
     }
 
-    const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- invalid commitment type %d from peer=%d\n", __func__,
                  std23::to_underlying(qc.llmqType), peer.GetId());
@@ -328,7 +328,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(Chainstate& chainstate, int nHeigh
 {
     AssertLockHeld(::cs_main);
 
-    const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "%s -- invalid commitment type %d\n", __func__, std23::to_underlying(qc.llmqType));
         return false;
@@ -481,11 +481,11 @@ std::optional<std::pair<QcHashMap, QcIndexedHashMap>> CQuorumBlockProcessor::Get
     m_qc_hashes_cached.clear();
     m_qc_indexed_hashes_cached.clear();
     if (!m_qc_hashes_lru.IsInitialized()) {
-        m_qc_hashes_lru.Init(Params().GetConsensus());
+        m_qc_hashes_lru.Init(m_chainman.GetConsensus());
     }
 
     for (const auto& [llmqType, vecBlockIndexes] : quorums) {
-        const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+        const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
         assert(llmq_params_opt.has_value());
         bool rotation_enabled = IsQuorumRotationEnabled(llmq_params_opt.value(), pindexPrev);
         auto& vec_hashes = m_qc_hashes_cached[llmqType];
@@ -537,7 +537,7 @@ bool CQuorumBlockProcessor::UndoBlock(const Chainstate& chainstate, const CBlock
             LogPrint(BCLog::LLMQ, "%s -- retaining commitment for block %s used by another chainstate\n",
                      __func__, pindex->GetBlockHash().ToString());
         } else {
-            const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
+            const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.llmqType);
             assert(llmq_params_opt.has_value());
 
             if (IsQuorumRotationEnabled(llmq_params_opt.value(), pindex)) {
@@ -584,7 +584,7 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no
 {
     AssertLockHeld(::cs_main);
 
-    const auto& consensus = Params().GetConsensus();
+    const auto& consensus = m_chainman.GetConsensus();
 
     ret.clear();
 
@@ -598,7 +598,7 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no
             }
             const auto& qc = *opt_qc;
 
-            const auto& llmq_params_opt = Params().GetLLMQ(qc.commitment.llmqType);
+            const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.commitment.llmqType);
             if (!llmq_params_opt.has_value()) {
                 // should not happen as it was verified before processing the block
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-commitment-type");
@@ -798,7 +798,7 @@ std::optional<const CBlockIndex*> CQuorumBlockProcessor::GetLastMinedCommitments
 std::vector<const CBlockIndex*> CQuorumBlockProcessor::GetLastMinedCommitmentsPerQuorumIndexUntilBlock(
     Consensus::LLMQType llmqType, const CBlockIndex* pindex, size_t cycle) const
 {
-    const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
     std::vector<const CBlockIndex*> ret;
 
@@ -838,7 +838,7 @@ std::map<Consensus::LLMQType, std::vector<const CBlockIndex*>> CQuorumBlockProce
 {
     std::map<Consensus::LLMQType, std::vector<const CBlockIndex*>> ret;
 
-    for (const auto& params : Params().GetConsensus().llmqs) {
+    for (const auto& params : m_chainman.GetConsensus().llmqs) {
         auto& commitments = ret[params.type];
         if (IsQuorumRotationEnabled(params, pindex)) {
             commitments = GetLastMinedCommitmentsPerQuorumIndexUntilBlock(params.type, pindex, 0);
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index 9a8e5705a527..f5758c53cd50 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -44,8 +44,7 @@ void CDKGSessionManager::UpdatedBlockTip(const CBlockIndex* pindexNew, bool fIni
 
     if (fInitialDownload)
         return;
-    if (!DeploymentDIP0003Enforced(pindexNew->nHeight, Params().GetConsensus()))
-        return;
+    if (!DeploymentDIP0003Enforced(pindexNew->nHeight, m_chainman.GetConsensus())) return;
     if (!IsQuorumDKGEnabled(m_sporkman))
         return;
 
@@ -240,7 +239,7 @@ void CDKGSessionManager::CleanupOldContributions() const
 
     const auto prefixes = {DB_VVEC, DB_SKCONTRIB, DB_ENC_CONTRIB};
 
-    for (const auto& params : Params().GetConsensus().llmqs) {
+    for (const auto& params : m_chainman.GetConsensus().llmqs) {
         LogPrint(BCLog::LLMQ, "CDKGSessionManager::%s -- looking for old entries for llmq type %d\n", __func__, std23::to_underlying(params.type));
 
         CDBBatch batch(*db);
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index 6e370e9a9846..d4f922792ebd 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -77,7 +77,7 @@ CQuorumPtr CQuorumManager::BuildQuorumFromCommitment(const Consensus::LLMQType l
     }
     assert(qc.quorumHash == pQuorumBaseBlockIndex->GetBlockHash());
 
-    const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
     auto members = utils::GetAllQuorumMembers(qc.llmqType, {m_dmnman, m_qsnapman, m_chainman, pQuorumBaseBlockIndex});
 
@@ -199,7 +199,7 @@ std::vector<T> CQuorumManager::ScanMined(Consensus::LLMQType llmqType, gsl::not_
     }
 
     gsl::not_null<const CBlockIndex*> pindexStore{pindexStart};
-    const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
 
     // Quorum sets can only change during the mining phase of DKG.
@@ -233,7 +233,7 @@ std::vector<T> CQuorumManager::ScanMined(Consensus::LLMQType llmqType, gsl::not_
             // And we only do this for max_cycles() of the most recent quorums
             // because signing by old quorums requires the exact quorum hash to be specified
             // and quorum scanning isn't needed there.
-            cache.Init(Params().GetConsensus(), [](const Consensus::LLMQParams& llmq) {
+            cache.Init(m_chainman.GetConsensus(), [](const Consensus::LLMQParams& llmq) {
                 return llmq.max_cycles(llmq.keepOldConnections) * (llmq.dkgMiningWindowEnd - llmq.dkgMiningWindowStart);
             });
         }

From 7403401051c1a5b5ede7052b1819064133aa19fb Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Sat, 7 Nov 2026 00:39:14 +0700
Subject: [PATCH 09/12] refactor: dissolve llmq/options into option args and
 quorum checks

llmq/options.{h,cpp} mixed the defaults and types of llmq options with
quorum logic: the spork-gated DKG/PoSe/all-connected checks, the rotation
check and the enabled-quorum lists. It also kept
GetEnabledQuorumVvecSyncEntries, which takes an ArgsManager and is only
called from init.cpp, in a file the kernel library builds.

Move the quorum checks unchanged to llmq/utils.{h,cpp}, next to the quorum
code that calls them. Move the option defaults, QvvecSyncMode and
GetEnabledQuorumVvecSyncEntries to llmq/options_args.{h,cpp} in the node
library, following the *_args.cpp layout upstream uses for option readers;
DEFAULT_WORKER_COUNT becomes an inline variable with the same name and
value, so no .cpp is needed for it. llmq/options.{h,cpp} go away.
---
 src/Makefile.am                        |   5 +-
 src/active/dkgsession.cpp              |   1 -
 src/active/dkgsessionhandler.cpp       |   1 +
 src/bench/bls.cpp                      |   2 +-
 src/bench/bls_dkg.cpp                  |   2 +-
 src/bitcoin-chainstate.cpp             |   2 +-
 src/evo/cbtx.cpp                       |   1 -
 src/evo/snapshot.cpp                   |   1 -
 src/init.cpp                           |   2 +-
 src/llmq/blockprocessor.cpp            |   1 -
 src/llmq/commitment.cpp                |   1 -
 src/llmq/context.h                     |   3 +-
 src/llmq/dkgsession.cpp                |   1 -
 src/llmq/dkgsessionmgr.cpp             |   1 -
 src/llmq/net_dkg.cpp                   |   1 -
 src/llmq/net_quorum.cpp                |   2 +-
 src/llmq/net_quorum.h                  |   2 +-
 src/llmq/net_signing.cpp               |   3 +-
 src/llmq/options.cpp                   | 137 -------------------------
 src/llmq/options_args.cpp              |  66 ++++++++++++
 src/llmq/{options.h => options_args.h} |  32 ++----
 src/llmq/quorumsman.cpp                |   1 -
 src/llmq/signing_shares.cpp            |   2 +-
 src/llmq/utils.cpp                     |  68 +++++++++++-
 src/llmq/utils.h                       |  11 ++
 src/net_processing.cpp                 |   1 -
 src/node/interfaces.cpp                |   2 +-
 src/node/miner.cpp                     |   2 +-
 src/rpc/quorums.cpp                    |   1 -
 src/test/evo_utils_tests.cpp           |   1 -
 src/test/llmq_qgetdata_tests.cpp       |   2 +-
 src/test/util/setup_common.cpp         |   2 +-
 32 files changed, 170 insertions(+), 190 deletions(-)
 delete mode 100644 src/llmq/options.cpp
 create mode 100644 src/llmq/options_args.cpp
 rename src/llmq/{options.h => options_args.h} (55%)

diff --git a/src/Makefile.am b/src/Makefile.am
index e6684ec9c2ae..9a6f41bf640a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -330,7 +330,7 @@ BITCOIN_CORE_H = \
   llmq/net_quorum.h \
   llmq/net_signing.h \
   llmq/observer.h \
-  llmq/options.h \
+  llmq/options_args.h \
   llmq/params.h \
   llmq/quorumproofdata.h \
   llmq/quorumproofs.h \
@@ -630,7 +630,7 @@ libbitcoin_node_a_SOURCES = \
   llmq/net_quorum.cpp \
   llmq/net_signing.cpp \
   llmq/observer.cpp \
-  llmq/options.cpp \
+  llmq/options_args.cpp \
   llmq/quorumproofs.cpp \
   llmq/quorums.cpp \
   llmq/quorumsman.cpp \
@@ -1348,7 +1348,6 @@ libdashkernel_la_SOURCES = \
   llmq/commitment.cpp \
   llmq/context.cpp \
   llmq/dkgsessionmgr.cpp \
-  llmq/options.cpp \
   llmq/quorums.cpp \
   llmq/quorumsman.cpp \
   llmq/signhash.cpp \
diff --git a/src/active/dkgsession.cpp b/src/active/dkgsession.cpp
index d3a7753c984b..98e5422289d7 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -10,7 +10,6 @@
 #include <llmq/debug.h>
 #include <llmq/dkgsessionhandler.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <util/helpers.h>
diff --git a/src/active/dkgsessionhandler.cpp b/src/active/dkgsessionhandler.cpp
index c11fcd3d18cd..1d540275efda 100644
--- a/src/active/dkgsessionhandler.cpp
+++ b/src/active/dkgsessionhandler.cpp
@@ -9,6 +9,7 @@
 #include <llmq/debug.h>
 #include <llmq/dkgsession.h>
 #include <llmq/net_quorum.h>
+#include <llmq/utils.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
diff --git a/src/bench/bls.cpp b/src/bench/bls.cpp
index d673d62a25b1..4e4cf76bda47 100644
--- a/src/bench/bls.cpp
+++ b/src/bench/bls.cpp
@@ -5,7 +5,7 @@
 #include <bench/bench.h>
 
 #include <bls/bls_worker.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 
 #include <random.h>
 #include <util/time.h>
diff --git a/src/bench/bls_dkg.cpp b/src/bench/bls_dkg.cpp
index bdf9015be8b7..0e3719643e1e 100644
--- a/src/bench/bls_dkg.cpp
+++ b/src/bench/bls_dkg.cpp
@@ -5,7 +5,7 @@
 #include <bench/bench.h>
 
 #include <bls/bls_worker.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <util/helpers.h>
 
 #include <random.h>
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index 9f7795f6c878..4a5be0957adb 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -28,7 +28,7 @@
 #include <evo/specialtxman.h>
 #include <init/common.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <masternode/meta.h>
 #include <node/blockstorage.h>
 #include <node/caches.h>
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index be084d47cdd6..a81a61a1648c 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -7,7 +7,6 @@
 #include <evo/specialtx.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <util/std23.h>
diff --git a/src/evo/snapshot.cpp b/src/evo/snapshot.cpp
index 04cffdba85e8..89c1f06cd529 100644
--- a/src/evo/snapshot.cpp
+++ b/src/evo/snapshot.cpp
@@ -13,7 +13,6 @@
 #include <evo/mnhftx.h>
 #include <evo/simplifiedmns.h>
 #include <hash.h>
-#include <llmq/options.h>
 #include <streams.h>
 #include <tinyformat.h>
 #include <util/check.h>
diff --git a/src/init.cpp b/src/init.cpp
index 9a695c2bb959..17d9f335f9dc 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -128,7 +128,7 @@
 #include <llmq/net_quorum.h>
 #include <llmq/net_signing.h>
 #include <llmq/observer.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
 #include <masternode/utils.h>
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 5f140c474216..71038471930d 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -7,7 +7,6 @@
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <util/helpers.h>
 #include <util/std23.h>
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index 3c4b91a6089e..038bb62c2c5d 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -5,7 +5,6 @@
 #include <llmq/commitment.h>
 
 #include <evo/deterministicmns.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <util/helpers.h>
 #include <util/std23.h>
diff --git a/src/llmq/context.h b/src/llmq/context.h
index 9033967bfc95..3176bc4e8c43 100644
--- a/src/llmq/context.h
+++ b/src/llmq/context.h
@@ -5,8 +5,7 @@
 #ifndef BITCOIN_LLMQ_CONTEXT_H
 #define BITCOIN_LLMQ_CONTEXT_H
 
-#include <llmq/options.h>
-
+#include <cstdint>
 #include <memory>
 
 class CBLSWorker;
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 848afca9f1ee..0f511feb0d2b 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -10,7 +10,6 @@
 #include <llmq/commitment.h>
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <util/helpers.h>
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index f5758c53cd50..77f81eab13fa 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -7,7 +7,6 @@
 #include <bls/bls_ies.h>
 #include <evo/deterministicmns.h>
 #include <llmq/dkgsessionhandler.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <spork.h>
 #include <unordered_lru_cache.h>
diff --git a/src/llmq/net_dkg.cpp b/src/llmq/net_dkg.cpp
index 279c7dbfd40c..d320c234af90 100644
--- a/src/llmq/net_dkg.cpp
+++ b/src/llmq/net_dkg.cpp
@@ -15,7 +15,6 @@
 #include <llmq/dkgsession.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/net_quorum.h>
-#include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
diff --git a/src/llmq/net_quorum.cpp b/src/llmq/net_quorum.cpp
index ef58ef006ea1..cde8776470b1 100644
--- a/src/llmq/net_quorum.cpp
+++ b/src/llmq/net_quorum.cpp
@@ -8,7 +8,7 @@
 #include <chainparams.h>
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <logging.h>
diff --git a/src/llmq/net_quorum.h b/src/llmq/net_quorum.h
index 9f0558be106c..3a34be575ecd 100644
--- a/src/llmq/net_quorum.h
+++ b/src/llmq/net_quorum.h
@@ -6,7 +6,7 @@
 #define BITCOIN_LLMQ_NET_QUORUM_H
 
 #include <llmq/cache.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/quorums.h>
 #include <net_processing.h>
 #include <sync.h>
diff --git a/src/llmq/net_signing.cpp b/src/llmq/net_signing.cpp
index 2deef488632e..5ab60edb8d9c 100644
--- a/src/llmq/net_signing.cpp
+++ b/src/llmq/net_signing.cpp
@@ -7,8 +7,9 @@
 #include <bls/bls_batchverifier.h>
 #include <llmq/quorums.h>
 #include <llmq/signhash.h>
-#include <llmq/signing_shares.h>
 #include <llmq/signing.h>
+#include <llmq/signing_shares.h>
+#include <llmq/utils.h>
 #include <spork.h>
 
 #include <logging.h>
diff --git a/src/llmq/options.cpp b/src/llmq/options.cpp
deleted file mode 100644
index 3b93c6610336..000000000000
--- a/src/llmq/options.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright (c) 2018-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 <common/args.h>
-#include <llmq/options.h>
-
-#include <spork.h>
-#include <util/helpers.h>
-#include <util/std23.h>
-
-#include <chainparams.h>
-#include <common/system.h>
-#include <consensus/params.h>
-#include <deploymentstatus.h>
-#include <validation.h>
-
-#include <algorithm>
-#include <ranges>
-#include <string>
-#include <stdexcept>
-#include <thread>
-
-namespace llmq {
-int16_t DEFAULT_WORKER_COUNT{std::clamp<int16_t>(std::thread::hardware_concurrency() / 2, 1, 4)};
-
-static bool EvalSpork(const Consensus::LLMQType llmqType, const int64_t spork_value)
-{
-    if (spork_value == 0) {
-        return true;
-    }
-    if (spork_value == 1 && llmqType != Consensus::LLMQType::LLMQ_100_67 && llmqType != Consensus::LLMQType::LLMQ_400_60 && llmqType != Consensus::LLMQType::LLMQ_400_85) {
-        return true;
-    }
-    return false;
-}
-
-bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
-{
-    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_21_QUORUM_ALL_CONNECTED));
-}
-
-bool IsQuorumDKGEnabled(const CSporkManager& sporkman) { return sporkman.IsSporkActive(SPORK_17_QUORUM_DKG_ENABLED); }
-
-bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
-{
-    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_23_QUORUM_POSE));
-}
-
-
-bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex)
-{
-    if (!llmqParams.useRotation) {
-        return false;
-    }
-
-    int cycleQuorumBaseHeight = pindex->nHeight - (pindex->nHeight % llmqParams.dkgInterval);
-    if (cycleQuorumBaseHeight < 1) {
-        return false;
-    }
-    // It should activate at least 1 block prior to the cycle start
-    return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024);
-}
-
-QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args)
-{
-    QvvecSyncModeMap mapQuorumVvecSyncEntries;
-    for (const auto& strEntry : args.GetArgs("-llmq-qvvec-sync")) {
-        Consensus::LLMQType llmqType = Consensus::LLMQType::LLMQ_NONE;
-        QvvecSyncMode mode{QvvecSyncMode::Invalid};
-        std::istringstream ssEntry(strEntry);
-        std::string strLLMQType, strMode, strTest;
-        const bool fLLMQTypePresent = std::getline(ssEntry, strLLMQType, ':') && strLLMQType != "";
-        const bool fModePresent = std::getline(ssEntry, strMode, ':') && strMode != "";
-        const bool fTooManyEntries = static_cast<bool>(std::getline(ssEntry, strTest, ':'));
-        if (!fLLMQTypePresent || !fModePresent || fTooManyEntries) {
-            throw std::invalid_argument(strprintf("Invalid format in -llmq-qvvec-sync: %s", strEntry));
-        }
-
-        if (auto optLLMQParams = util::find_if_opt(Params().GetConsensus().llmqs, [&strLLMQType](const auto& params) {
-                return params.name == strLLMQType;
-            })) {
-            llmqType = optLLMQParams->type;
-        } else {
-            throw std::invalid_argument(strprintf("Invalid llmqType in -llmq-qvvec-sync: %s", strEntry));
-        }
-        if (mapQuorumVvecSyncEntries.count(llmqType) > 0) {
-            throw std::invalid_argument(strprintf("Duplicated llmqType in -llmq-qvvec-sync: %s", strEntry));
-        }
-
-        int32_t nMode;
-        if (ParseInt32(strMode, &nMode)) {
-            switch (nMode) {
-            case static_cast<int32_t>(QvvecSyncMode::Always):
-                mode = QvvecSyncMode::Always;
-                break;
-            case static_cast<int32_t>(QvvecSyncMode::OnlyIfTypeMember):
-                mode = QvvecSyncMode::OnlyIfTypeMember;
-                break;
-            default:
-                mode = QvvecSyncMode::Invalid;
-                break;
-            }
-        }
-        if (mode == QvvecSyncMode::Invalid) {
-            throw std::invalid_argument(strprintf("Invalid mode in -llmq-qvvec-sync: %s", strEntry));
-        }
-        mapQuorumVvecSyncEntries.emplace(llmqType, mode);
-    }
-    return mapQuorumVvecSyncEntries;
-}
-
-std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
-                                                       gsl::not_null<const CBlockIndex*> pindex)
-{
-    std::vector<Consensus::LLMQType> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-    for (const auto& params : Params().GetConsensus().llmqs) {
-        if (chainman.IsQuorumTypeEnabled(params.type, pindex)) {
-            ret.push_back(params.type);
-        }
-    }
-    return ret;
-}
-
-std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
-    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex)
-{
-    std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-
-    std::copy_if(Params().GetConsensus().llmqs.begin(), Params().GetConsensus().llmqs.end(), std::back_inserter(ret),
-                 [&pindex, &chainman](const auto& params) { return chainman.IsQuorumTypeEnabled(params.type, pindex); });
-
-    return ret;
-}
-} // namespace llmq
diff --git a/src/llmq/options_args.cpp b/src/llmq/options_args.cpp
new file mode 100644
index 000000000000..64cde1d67af1
--- /dev/null
+++ b/src/llmq/options_args.cpp
@@ -0,0 +1,66 @@
+// Copyright (c) 2014-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 <llmq/options_args.h>
+
+#include <chainparams.h>
+#include <common/args.h>
+#include <consensus/params.h>
+#include <tinyformat.h>
+#include <util/helpers.h>
+#include <util/strencodings.h>
+
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace llmq {
+QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args)
+{
+    QvvecSyncModeMap mapQuorumVvecSyncEntries;
+    for (const auto& strEntry : args.GetArgs("-llmq-qvvec-sync")) {
+        Consensus::LLMQType llmqType = Consensus::LLMQType::LLMQ_NONE;
+        QvvecSyncMode mode{QvvecSyncMode::Invalid};
+        std::istringstream ssEntry(strEntry);
+        std::string strLLMQType, strMode, strTest;
+        const bool fLLMQTypePresent = std::getline(ssEntry, strLLMQType, ':') && strLLMQType != "";
+        const bool fModePresent = std::getline(ssEntry, strMode, ':') && strMode != "";
+        const bool fTooManyEntries = static_cast<bool>(std::getline(ssEntry, strTest, ':'));
+        if (!fLLMQTypePresent || !fModePresent || fTooManyEntries) {
+            throw std::invalid_argument(strprintf("Invalid format in -llmq-qvvec-sync: %s", strEntry));
+        }
+
+        if (auto optLLMQParams = util::find_if_opt(Params().GetConsensus().llmqs, [&strLLMQType](const auto& params) {
+                return params.name == strLLMQType;
+            })) {
+            llmqType = optLLMQParams->type;
+        } else {
+            throw std::invalid_argument(strprintf("Invalid llmqType in -llmq-qvvec-sync: %s", strEntry));
+        }
+        if (mapQuorumVvecSyncEntries.count(llmqType) > 0) {
+            throw std::invalid_argument(strprintf("Duplicated llmqType in -llmq-qvvec-sync: %s", strEntry));
+        }
+
+        int32_t nMode;
+        if (ParseInt32(strMode, &nMode)) {
+            switch (nMode) {
+            case static_cast<int32_t>(QvvecSyncMode::Always):
+                mode = QvvecSyncMode::Always;
+                break;
+            case static_cast<int32_t>(QvvecSyncMode::OnlyIfTypeMember):
+                mode = QvvecSyncMode::OnlyIfTypeMember;
+                break;
+            default:
+                mode = QvvecSyncMode::Invalid;
+                break;
+            }
+        }
+        if (mode == QvvecSyncMode::Invalid) {
+            throw std::invalid_argument(strprintf("Invalid mode in -llmq-qvvec-sync: %s", strEntry));
+        }
+        mapQuorumVvecSyncEntries.emplace(llmqType, mode);
+    }
+    return mapQuorumVvecSyncEntries;
+}
+} // namespace llmq
diff --git a/src/llmq/options.h b/src/llmq/options_args.h
similarity index 55%
rename from src/llmq/options.h
rename to src/llmq/options_args.h
index 8bb0b22b1f06..abc53b2c4d86 100644
--- a/src/llmq/options.h
+++ b/src/llmq/options_args.h
@@ -1,22 +1,17 @@
-// Copyright (c) 2018-2025 The Dash Core developers
+// Copyright (c) 2014-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_LLMQ_OPTIONS_H
-#define BITCOIN_LLMQ_OPTIONS_H
-
-#include <gsl/pointers.h>
+#ifndef BITCOIN_LLMQ_OPTIONS_ARGS_H
+#define BITCOIN_LLMQ_OPTIONS_ARGS_H
 
+#include <algorithm>
+#include <cstdint>
 #include <map>
-#include <optional>
-#include <vector>
+#include <thread>
 
 class ArgsManager;
-class CBlockIndex;
-class ChainstateManager;
-class CSporkManager;
 namespace Consensus {
-struct LLMQParams;
 enum class LLMQType : uint8_t;
 } // namespace Consensus
 
@@ -37,23 +32,14 @@ static constexpr bool DEFAULT_WATCH_QUORUMS{false};
 /** -parbls default (number of bls-checking threads, 0 = auto) */
 static constexpr int8_t DEFAULT_BLSCHECK_THREADS{0};
 /** Number of workers allocated per worker pool */
-extern int16_t DEFAULT_WORKER_COUNT;
+inline const int16_t DEFAULT_WORKER_COUNT{std::clamp<int16_t>(std::thread::hardware_concurrency() / 2, 1, 4)};
 /** Maximum number of dedicated script-checking threads allowed */
 static constexpr int8_t MAX_BLSCHECK_THREADS{33};
 
-bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
-bool IsQuorumDKGEnabled(const CSporkManager& sporkman);
-bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
-bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
+using QvvecSyncModeMap = std::map<Consensus::LLMQType, QvvecSyncMode>;
 
 /// Returns the parsed entries given by `-llmq-qvvec-sync`
-using QvvecSyncModeMap = std::map<Consensus::LLMQType, QvvecSyncMode>;
 QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args);
-
-std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
-                                                       gsl::not_null<const CBlockIndex*> pindex);
-std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
-    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex);
 } // namespace llmq
 
-#endif // BITCOIN_LLMQ_OPTIONS_H
+#endif // BITCOIN_LLMQ_OPTIONS_ARGS_H
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index d4f922792ebd..48a8fd5bbcdf 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -11,7 +11,6 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/options.h>
 #include <llmq/params.h>
 #include <llmq/signhash.h>
 #include <llmq/utils.h>
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 5dd6ce91a3bc..5aa2df60dea1 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -8,11 +8,11 @@
 #include <chainparams.h>
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
 #include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
+#include <llmq/utils.h>
 #include <netmessagemaker.h>
 #include <util/helpers.h>
 #include <util/std23.h>
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 0d34b0c43dcf..2956c7fb7d0a 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -7,10 +7,10 @@
 #include <bls/bls.h>
 #include <evo/deterministicmns.h>
 #include <llmq/cache.h>
-#include <llmq/options.h>
 #include <llmq/snapshot.h>
 #include <llmq/types.h>
 #include <masternode/meta.h>
+#include <spork.h>
 #include <util/helpers.h>
 #include <util/std23.h>
 
@@ -20,7 +20,9 @@
 #include <util/time.h>
 #include <validation.h>
 
+#include <algorithm>
 #include <atomic>
+#include <iterator>
 #include <map>
 #include <optional>
 
@@ -547,6 +549,70 @@ std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus
 } // anonymous namespace
 
 namespace llmq {
+static bool EvalSpork(const Consensus::LLMQType llmqType, const int64_t spork_value)
+{
+    if (spork_value == 0) {
+        return true;
+    }
+    if (spork_value == 1 && llmqType != Consensus::LLMQType::LLMQ_100_67 &&
+        llmqType != Consensus::LLMQType::LLMQ_400_60 && llmqType != Consensus::LLMQType::LLMQ_400_85) {
+        return true;
+    }
+    return false;
+}
+
+bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
+{
+    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_21_QUORUM_ALL_CONNECTED));
+}
+
+bool IsQuorumDKGEnabled(const CSporkManager& sporkman) { return sporkman.IsSporkActive(SPORK_17_QUORUM_DKG_ENABLED); }
+
+bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
+{
+    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_23_QUORUM_POSE));
+}
+
+bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex)
+{
+    if (!llmqParams.useRotation) {
+        return false;
+    }
+
+    int cycleQuorumBaseHeight = pindex->nHeight - (pindex->nHeight % llmqParams.dkgInterval);
+    if (cycleQuorumBaseHeight < 1) {
+        return false;
+    }
+    // It should activate at least 1 block prior to the cycle start
+    return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(),
+                                 Consensus::DEPLOYMENT_DIP0024);
+}
+
+std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
+                                                       gsl::not_null<const CBlockIndex*> pindex)
+{
+    std::vector<Consensus::LLMQType> ret;
+    ret.reserve(Params().GetConsensus().llmqs.size());
+    for (const auto& params : Params().GetConsensus().llmqs) {
+        if (chainman.IsQuorumTypeEnabled(params.type, pindex)) {
+            ret.push_back(params.type);
+        }
+    }
+    return ret;
+}
+
+std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
+    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex)
+{
+    std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
+    ret.reserve(Params().GetConsensus().llmqs.size());
+
+    std::copy_if(Params().GetConsensus().llmqs.begin(), Params().GetConsensus().llmqs.end(), std::back_inserter(ret),
+                 [&pindex, &chainman](const auto& params) { return chainman.IsQuorumTypeEnabled(params.type, pindex); });
+
+    return ret;
+}
+
 namespace utils {
 BlsCheck::BlsCheck() = default;
 
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 65c4c2682808..b471c084a767 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -16,6 +16,7 @@
 
 #include <gsl/pointers.h>
 
+#include <functional>
 #include <optional>
 #include <unordered_set>
 #include <vector>
@@ -42,6 +43,16 @@ struct UtilParameters {
     }
 };
 
+bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
+bool IsQuorumDKGEnabled(const CSporkManager& sporkman);
+bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
+bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
+
+std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
+                                                       gsl::not_null<const CBlockIndex*> pindex);
+std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
+    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex);
+
 namespace utils {
 struct BlsCheck {
     CBLSSignature m_sig;
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index b285de58a8d6..dd68b49cd611 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -57,7 +57,6 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index a12196d561e9..a821835674ea 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -36,9 +36,9 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
+#include <llmq/utils.h>
 #include <logging.h>
 #include <mapport.h>
 #include <masternode/sync.h>
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index ca84a4b531da..1def21c59a01 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -38,8 +38,8 @@
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/snapshot.h>
+#include <llmq/utils.h>
 #include <masternode/payments.h>
 
 #include <algorithm>
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 3d211138d3ea..afa56484bd37 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -15,7 +15,6 @@
 #include <llmq/dkgsession.h>
 #include <llmq/dkgsessionhandler.h>
 #include <llmq/observer.h>
-#include <llmq/options.h>
 #include <llmq/quorumproofs.h>
 #include <evo/simplifiedmns.h>
 #include <clientversion.h>
diff --git a/src/test/evo_utils_tests.cpp b/src/test/evo_utils_tests.cpp
index 4f70b0024821..4488edcf2e08 100644
--- a/src/test/evo_utils_tests.cpp
+++ b/src/test/evo_utils_tests.cpp
@@ -6,7 +6,6 @@
 
 #include <chainparams.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <validation.h>
 
diff --git a/src/test/llmq_qgetdata_tests.cpp b/src/test/llmq_qgetdata_tests.cpp
index 65a0527c30d2..14d9eb45e1ac 100644
--- a/src/test/llmq_qgetdata_tests.cpp
+++ b/src/test/llmq_qgetdata_tests.cpp
@@ -5,7 +5,7 @@
 #include <arith_uint256.h>
 #include <llmq/context.h>
 #include <llmq/net_quorum.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
 #include <net.h>
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index f8cfedbbc909..dccfbefccd41 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -90,7 +90,7 @@
 #include <governance/superblock.h>
 #include <instantsend/instantsend.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/signing.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>

From 1fff770942088fcae8d65c439a1529dd94052f47 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Mon, 9 Nov 2026 01:34:16 +0700
Subject: [PATCH 10/12] refactor: read enabled quorums from the supplied
 ChainstateManager

GetEnabledQuorumTypes and GetEnabledQuorumParams filter quorum types through the ChainstateManager they are given, but enumerated the quorum list from the Params() global. Take the list from that manager too.
---
 src/llmq/utils.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 2956c7fb7d0a..541de71ed982 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -592,8 +592,8 @@ std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager&
                                                        gsl::not_null<const CBlockIndex*> pindex)
 {
     std::vector<Consensus::LLMQType> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-    for (const auto& params : Params().GetConsensus().llmqs) {
+    ret.reserve(chainman.GetConsensus().llmqs.size());
+    for (const auto& params : chainman.GetConsensus().llmqs) {
         if (chainman.IsQuorumTypeEnabled(params.type, pindex)) {
             ret.push_back(params.type);
         }
@@ -605,9 +605,9 @@ std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuoru
     const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex)
 {
     std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
+    ret.reserve(chainman.GetConsensus().llmqs.size());
 
-    std::copy_if(Params().GetConsensus().llmqs.begin(), Params().GetConsensus().llmqs.end(), std::back_inserter(ret),
+    std::copy_if(chainman.GetConsensus().llmqs.begin(), chainman.GetConsensus().llmqs.end(), std::back_inserter(ret),
                  [&pindex, &chainman](const auto& params) { return chainman.IsQuorumTypeEnabled(params.type, pindex); });
 
     return ret;

From bddf5f5399d68a62ae9f06bf93bddd30aceff48c Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:37:49 +0700
Subject: [PATCH 11/12] Merge bitcoin/bitcoin#27636: kernel: Remove util/system
 from kernel library, interface_ui from validation.

Removes common/system.cpp as RenameThreadPool lives in util/thread.cpp and completes backport
---
 src/Makefile.am                      | 1 -
 src/kernel/notifications_interface.h | 2 ++
 src/node/kernel_notifications.cpp    | 5 +++++
 src/node/kernel_notifications.h      | 3 +++
 src/validation.cpp                   | 5 ++---
 5 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/Makefile.am b/src/Makefile.am
index 9a6f41bf640a..de1b74650206 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1300,7 +1300,6 @@ libdashkernel_la_SOURCES = \
   common/bloom.cpp \
   common/config.cpp \
   common/settings.cpp \
-  common/system.cpp \
   compressor.cpp \
   consensus/merkle.cpp \
   consensus/tx_check.cpp \
diff --git a/src/kernel/notifications_interface.h b/src/kernel/notifications_interface.h
index 48248e9aa0b6..af5867af9989 100644
--- a/src/kernel/notifications_interface.h
+++ b/src/kernel/notifications_interface.h
@@ -9,6 +9,7 @@
 #include <string>
 
 class CBlockIndex;
+class CDeterministicMNList;
 enum class SynchronizationState;
 struct bilingual_str;
 
@@ -27,6 +28,7 @@ class Notifications
     virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
     virtual void progress(const bilingual_str& title, int progress_percent, bool resume_possible) {}
     virtual void warning(const bilingual_str& warning) {}
+    virtual void masternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* index) {}
 };
 } // namespace kernel
 
diff --git a/src/node/kernel_notifications.cpp b/src/node/kernel_notifications.cpp
index f9010a065133..cf73279c10ca 100644
--- a/src/node/kernel_notifications.cpp
+++ b/src/node/kernel_notifications.cpp
@@ -72,4 +72,9 @@ void KernelNotifications::warning(const bilingual_str& warning)
     DoWarning(warning);
 }
 
+void KernelNotifications::masternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* index)
+{
+    uiInterface.NotifyMasternodeListChanged(list, index);
+}
+
 } // namespace node
diff --git a/src/node/kernel_notifications.h b/src/node/kernel_notifications.h
index 3e665bbf14e5..f1591f13825f 100644
--- a/src/node/kernel_notifications.h
+++ b/src/node/kernel_notifications.h
@@ -11,6 +11,7 @@
 #include <string>
 
 class CBlockIndex;
+class CDeterministicMNList;
 enum class SynchronizationState;
 struct bilingual_str;
 
@@ -25,6 +26,8 @@ class KernelNotifications : public kernel::Notifications
     void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override;
 
     void warning(const bilingual_str& warning) override;
+
+    void masternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* index) override;
 };
 } // namespace node
 
diff --git a/src/validation.cpp b/src/validation.cpp
index f4b3c9a7100c..0e44f680132c 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -35,7 +35,6 @@
 #include <logging.h>
 #include <logging/timer.h>
 #include <node/blockstorage.h>
-#include <node/interface_ui.h>
 #include <node/utxo_snapshot.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -2378,7 +2377,7 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
 
     if (this == &m_chainman.ActiveChainstate() && mnlist_updates.diff.HasChanges()) {
         GetMainSignals().NotifyMasternodeListChanged(true, mnlist_updates.old_list, mnlist_updates.diff);
-        uiInterface.NotifyMasternodeListChanged(mnlist_updates.new_list, pindex->pprev);
+        m_chainman.GetNotifications().masternodeListChanged(mnlist_updates.new_list, pindex->pprev);
     }
 
     auto finish = Now<SteadyMilliseconds>();
@@ -3107,7 +3106,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     if (this == &m_chainman.ActiveChainstate() && mnlist_updates.diff.HasChanges()) {
         GetMainSignals().NotifyMasternodeListChanged(false, mnlist_updates.old_list, mnlist_updates.diff);
-        uiInterface.NotifyMasternodeListChanged(mnlist_updates.new_list, pindex);
+        m_chainman.GetNotifications().masternodeListChanged(mnlist_updates.new_list, pindex);
     }
 
     ::g_stats_client->timing("ConnectBlock_ms", Ticks<std::chrono::milliseconds>(time_8 - time_start), 1.0f);

From 1b6a48e5a7e13723b301d1d04e4a6d4deab2d11b Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Nov 2026 22:37:49 +0700
Subject: [PATCH 12/12] fix: follow-up for bitcoin#27576: drop node-only index
 and transaction code from the kernel library

index/base.cpp, index/txindex.cpp, node/transaction.cpp, node/database_args.cpp and init/common.cpp were only in the Dash kernel because validation resolved InstantSend conflicts through node::GetTransaction(); with that lookup moved to the zmq notifier they have no kernel consumer left.

common/args.cpp, common/config.cpp, common/settings.cpp, chainparams.cpp and chainparamsbase.cpp stay: Dash's evo, llmq and key_io kernel code still reads the Params() global, which lives in chainparams.cpp next to the ArgsManager option readers so 27576 is still partial
---
 src/Makefile.am | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/Makefile.am b/src/Makefile.am
index de1b74650206..5a2dcc63396b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1327,9 +1327,6 @@ libdashkernel_la_SOURCES = \
   gsl/assert.cpp \
   hash.cpp \
   index/addressindex_util.cpp \
-  index/base.cpp \
-  index/txindex.cpp \
-  init/common.cpp \
   instantsend/db.cpp \
   instantsend/instantsend.cpp \
   instantsend/lock.cpp \
@@ -1362,9 +1359,7 @@ libdashkernel_la_SOURCES = \
   netbase.cpp \
   node/blockstorage.cpp \
   node/chainstate.cpp \
-  node/database_args.cpp \
   node/interface_ui.cpp \
-  node/transaction.cpp \
   node/utxo_snapshot.cpp \
   policy/feerate.cpp \
   policy/fees.cpp \