diff --git a/src/Makefile.am b/src/Makefile.am
index 0724e19a22da..e6684ec9c2ae 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -205,6 +205,7 @@ BITCOIN_CORE_H = \
   coinjoin/util.h \
   coinjoin/walletman.h \
   coins.h \
+  common/args.h \
   common/bloom.h \
   common/init.h \
   common/run_command.h \
@@ -214,6 +215,8 @@ BITCOIN_CORE_H = \
   compat/compat.h \
   compat/cpuid.h \
   compat/endian.h \
+  common/settings.h \
+  common/system.h \
   compressor.h \
   consensus/consensus.h \
   consensus/tx_check.h \
@@ -308,6 +311,7 @@ BITCOIN_CORE_H = \
   kernel/mempool_limits.h \
   kernel/mempool_options.h \
   kernel/mempool_persist.h \
+  kernel/notifications_interface.h \
   kernel/validation_cache_sizes.h \
   key.h \
   key_io.h \
@@ -370,6 +374,7 @@ BITCOIN_CORE_H = \
   node/database_args.h \
   node/eviction.h \
   node/interface_ui.h \
+  node/kernel_notifications.h \
   node/mempool_args.h \
   node/mempool_persist_args.h \
   node/miner.h \
@@ -441,10 +446,13 @@ BITCOIN_CORE_H = \
   txrequest.h \
   undo.h \
   unordered_lru_cache.h \
+  util/any.h \
   util/asmap.h \
+  util/batchpriority.h \
   util/bip32.h \
   util/bitset.h \
   util/bytevectorhash.h \
+  util/chaintype.h \
   util/check.h \
   util/edge.h \
   util/epochguard.h \
@@ -458,6 +466,7 @@ BITCOIN_CORE_H = \
   util/hash_type.h \
   util/hasher.h \
   util/helpers.h \
+  util/insert.h \
   util/macros.h \
   util/message.h \
   util/moneystr.h \
@@ -467,14 +476,12 @@ BITCOIN_CORE_H = \
   util/readwritefile.h \
   util/result.h \
   util/serfloat.h \
-  util/settings.h \
   util/sock.h \
   util/spanparsing.h \
   util/std23.h \
   util/string.h \
   util/subprocess.h \
   util/syserror.h \
-  util/system.h \
   util/thread.h \
   util/threadinterrupt.h \
   util/threadnames.h \
@@ -654,6 +661,7 @@ libbitcoin_node_a_SOURCES = \
   node/eviction.cpp \
   node/interface_ui.cpp \
   node/interfaces.cpp \
+  node/kernel_notifications.cpp \
   node/mempool_args.cpp \
   node/mempool_persist_args.cpp \
   node/miner.cpp \
@@ -999,10 +1007,14 @@ libbitcoin_common_a_SOURCES = \
   bech32.cpp \
   chainparams.cpp \
   coins.cpp \
+  common/args.cpp \
   common/bloom.cpp \
+  common/config.cpp \
   common/init.cpp \
   common/interfaces.cpp \
   common/run_command.cpp \
+  common/settings.cpp \
+  common/system.cpp \
   common/url.cpp \
   compressor.cpp \
   core_read.cpp \
@@ -1066,8 +1078,10 @@ libbitcoin_util_a_SOURCES = \
   support/lockedpool.cpp \
   sync.cpp \
   util/asmap.cpp \
+  util/batchpriority.cpp \
   util/bip32.cpp \
   util/bytevectorhash.cpp \
+  util/chaintype.cpp \
   util/check.cpp \
   util/edge.cpp \
   util/error.cpp \
@@ -1081,13 +1095,11 @@ libbitcoin_util_a_SOURCES = \
   util/ranges_set.cpp \
   util/readwritefile.cpp \
   util/serfloat.cpp \
-  util/settings.cpp \
   util/sock.cpp \
   util/spanparsing.cpp \
   util/strencodings.cpp \
   util/string.cpp \
   util/syserror.cpp \
-  util/system.cpp \
   util/thread.cpp \
   util/threadinterrupt.cpp \
   util/threadnames.cpp \
@@ -1284,7 +1296,11 @@ libdashkernel_la_SOURCES = \
   chainparamsbase.cpp \
   clientversion.cpp \
   coins.cpp \
+  common/args.cpp \
   common/bloom.cpp \
+  common/config.cpp \
+  common/settings.cpp \
+  common/system.cpp \
   compressor.cpp \
   consensus/merkle.cpp \
   consensus/tx_check.cpp \
@@ -1381,7 +1397,9 @@ libdashkernel_la_SOURCES = \
   txdb.cpp \
   txmempool.cpp \
   uint256.cpp \
+  util/batchpriority.cpp \
   util/bytevectorhash.cpp \
+  util/chaintype.cpp \
   util/check.cpp \
   util/exception.cpp \
   util/fs.cpp \
@@ -1391,12 +1409,10 @@ libdashkernel_la_SOURCES = \
   util/moneystr.cpp \
   util/ranges_set.cpp \
   util/serfloat.cpp \
-  util/settings.cpp \
   util/sock.cpp \
   util/strencodings.cpp \
   util/string.cpp \
   util/syserror.cpp \
-  util/system.cpp \
   util/thread.cpp \
   util/threadinterrupt.cpp \
   util/threadnames.cpp \
diff --git a/src/active/masternode.cpp b/src/active/masternode.cpp
index 7565c013e2a9..20561768e686 100644
--- a/src/active/masternode.cpp
+++ b/src/active/masternode.cpp
@@ -8,6 +8,7 @@
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
+#include <logging.h>
 #include <net.h>
 #include <netbase.h>
 #include <protocol.h>
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index db476cc3f0b1..cac7c380f9f1 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -12,6 +12,7 @@
 #include <addrman.h>
 #include <chainparams.h>
 #include <clientversion.h>
+#include <common/args.h>
 #include <hash.h>
 #include <logging.h>
 #include <logging/timer.h>
@@ -23,8 +24,6 @@
 #include <univalue.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
-#include <util/settings.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <cstdint>
@@ -140,7 +139,7 @@ CBanDB::CBanDB(fs::path ban_list_path)
 bool CBanDB::Write(const banmap_t& banSet)
 {
     std::vector<std::string> errors;
-    if (util::WriteSettings(m_banlist_json, {{JSON_KEY, BanMapToJson(banSet)}}, errors)) {
+    if (common::WriteSettings(m_banlist_json, {{JSON_KEY, BanMapToJson(banSet)}}, errors)) {
         return true;
     }
 
@@ -160,10 +159,10 @@ bool CBanDB::Read(banmap_t& banSet)
         return false;
     }
 
-    std::map<std::string, util::SettingsValue> settings;
+    std::map<std::string, common::SettingsValue> settings;
     std::vector<std::string> errors;
 
-    if (!util::ReadSettings(m_banlist_json, settings, errors)) {
+    if (!common::ReadSettings(m_banlist_json, settings, errors)) {
         for (const auto& err : errors) {
             LogPrintf("Cannot load banlist %s: %s\n", fs::PathToString(m_banlist_json), err);
         }
diff --git a/src/banman.cpp b/src/banman.cpp
index f1c0eac20fbd..a128c83324a0 100644
--- a/src/banman.cpp
+++ b/src/banman.cpp
@@ -5,10 +5,11 @@
 
 #include <banman.h>
 
+#include <common/system.h>
+#include <logging.h>
 #include <netaddress.h>
 #include <node/interface_ui.h>
 #include <sync.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 
diff --git a/src/bench/bench_bitcoin.cpp b/src/bench/bench_bitcoin.cpp
index 38eb9e682014..785c98c87440 100644
--- a/src/bench/bench_bitcoin.cpp
+++ b/src/bench/bench_bitcoin.cpp
@@ -6,11 +6,11 @@
 
 #include <bls/bls.h>
 #include <clientversion.h>
+#include <common/args.h>
 #include <crypto/sha256.h>
 #include <crypto/x11/dispatch.h>
 #include <util/fs.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 
 #include <chrono>
 #include <cstdint>
diff --git a/src/bench/checkblock.cpp b/src/bench/checkblock.cpp
index a297fbea8363..f2130073dd14 100644
--- a/src/bench/checkblock.cpp
+++ b/src/bench/checkblock.cpp
@@ -6,10 +6,11 @@
 #include <bench/data.h>
 
 #include <chainparams.h>
+#include <common/args.h>
 #include <consensus/validation.h>
 #include <stats/client.h>
 #include <streams.h>
-#include <util/system.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <memory>
@@ -39,7 +40,7 @@ static void DeserializeAndCheckBlockTest(benchmark::Bench& bench)
     stream.write({&a, 1}); // Prevent compaction
 
     ArgsManager bench_args;
-    const auto chainParams = CreateChainParams(bench_args, CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(bench_args, ChainType::MAIN);
     // CheckBlock calls g_stats_client internally, we aren't using a testing setup
     // so we need to do this manually. We can use the stub interface for this.
     ::g_stats_client = std::make_unique<StatsdClient>();
diff --git a/src/bench/checkqueue.cpp b/src/bench/checkqueue.cpp
index bb71af945798..6379daf26792 100644
--- a/src/bench/checkqueue.cpp
+++ b/src/bench/checkqueue.cpp
@@ -4,11 +4,11 @@
 
 #include <bench/bench.h>
 #include <checkqueue.h>
+#include <common/system.h>
 #include <key.h>
 #include <prevector.h>
 #include <pubkey.h>
 #include <random.h>
-#include <util/system.h>
 
 #include <vector>
 
diff --git a/src/bench/load_external.cpp b/src/bench/load_external.cpp
index c99d6d0c7496..2ec7b8d59423 100644
--- a/src/bench/load_external.cpp
+++ b/src/bench/load_external.cpp
@@ -6,6 +6,7 @@
 #include <bench/data.h>
 #include <chainparams.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 /**
@@ -22,7 +23,7 @@
  */
 static void LoadExternalBlockFile(benchmark::Bench& bench)
 {
-    const auto testing_setup{MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN)};
+    const auto testing_setup{MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN)};
 
     // Create a single block as in the blocks files (magic bytes, block size,
     // block data) as a stream object.
diff --git a/src/bench/logging.cpp b/src/bench/logging.cpp
index 9aedb26236df..c97c4e151b6b 100644
--- a/src/bench/logging.cpp
+++ b/src/bench/logging.cpp
@@ -5,6 +5,7 @@
 #include <bench/bench.h>
 #include <logging.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 
 // All but 2 of the benchmarks should have roughly similar performance:
 //
@@ -18,7 +19,7 @@ static void Logging(benchmark::Bench& bench, const std::vector<const char*>& ext
     LogInstance().DisableCategory(BCLog::LogFlags::ALL);
 
     TestingSetup test_setup{
-        CBaseChainParams::REGTEST,
+        ChainType::REGTEST,
         extra_args,
     };
 
diff --git a/src/bench/mempool_stress.cpp b/src/bench/mempool_stress.cpp
index 456885811416..827d36e60463 100644
--- a/src/bench/mempool_stress.cpp
+++ b/src/bench/mempool_stress.cpp
@@ -7,6 +7,7 @@
 #include <policy/policy.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <vector>
@@ -86,7 +87,7 @@ static void ComplexMemPool(benchmark::Bench& bench)
         childTxs = static_cast<int>(bench.complexityN());
     }
     std::vector<CTransactionRef> ordered_coins = CreateOrderedCoins(det_rand, childTxs, /*min_ancestors=*/1);
-    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN);
+    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN);
     CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
     LOCK2(cs_main, pool.cs);
     bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
@@ -101,7 +102,7 @@ static void ComplexMemPool(benchmark::Bench& bench)
 static void MempoolCheck(benchmark::Bench& bench)
 {
     FastRandomContext det_rand{true};
-    auto testing_setup = MakeNoLogFileContext<TestChain100Setup>(CBaseChainParams::REGTEST, {"-checkmempool=1"});
+    auto testing_setup = MakeNoLogFileContext<TestChain100Setup>(ChainType::REGTEST, {"-checkmempool=1"});
     CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
     LOCK2(cs_main, pool.cs);
     testing_setup->PopulateMempool(det_rand, 400, true);
diff --git a/src/bench/net_processing.cpp b/src/bench/net_processing.cpp
index f690d4a96c6d..cdb9b671d2be 100644
--- a/src/bench/net_processing.cpp
+++ b/src/bench/net_processing.cpp
@@ -14,7 +14,7 @@ using namespace std::literals;
 
 static void InventoryBatch(benchmark::Bench& bench, uint32_t count)
 {
-    const auto setup = MakeNoLogFileContext<TestingSetup>(CBaseChainParams::REGTEST);
+    const auto setup = MakeNoLogFileContext<TestingSetup>(ChainType::REGTEST);
     auto& chainstate = *static_cast<TestChainState*>(&setup->m_node.chainman->ActiveChainstate());
     chainstate.JumpOutOfIbd();
     auto& peerman = *setup->m_node.peerman;
diff --git a/src/bench/rpc_blockchain.cpp b/src/bench/rpc_blockchain.cpp
index 62882bf6343e..27b5198d5a27 100644
--- a/src/bench/rpc_blockchain.cpp
+++ b/src/bench/rpc_blockchain.cpp
@@ -11,6 +11,7 @@
 #include <rpc/blockchain.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <univalue.h>
@@ -18,7 +19,7 @@
 namespace {
 
 struct TestBlockAndIndex {
-    const std::unique_ptr<const TestingSetup> testing_setup{MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN)};
+    const std::unique_ptr<const TestingSetup> testing_setup{MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN)};
     CBlock block{};
     uint256 blockHash{};
     CBlockIndex blockindex{};
diff --git a/src/bench/rpc_mempool.cpp b/src/bench/rpc_mempool.cpp
index 23951537c708..37fd8e203e1e 100644
--- a/src/bench/rpc_mempool.cpp
+++ b/src/bench/rpc_mempool.cpp
@@ -3,12 +3,12 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
-#include <chainparamsbase.h>
 #include <kernel/cs_main.h>
 #include <kernel/mempool_entry.h>
 #include <rpc/mempool.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
+#include <util/chaintype.h>
 
 #include <univalue.h>
 
@@ -21,7 +21,7 @@ static void AddTx(const CTransactionRef& tx, const CAmount& fee, CTxMemPool& poo
 
 static void RpcMempool(benchmark::Bench& bench)
 {
-    const auto testing_setup = MakeNoLogFileContext<const ChainTestingSetup>(CBaseChainParams::MAIN);
+    const auto testing_setup = MakeNoLogFileContext<const ChainTestingSetup>(ChainType::MAIN);
     CTxMemPool& pool = *Assert(testing_setup->m_node.mempool);
     LOCK2(cs_main, pool.cs);
 
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index de391c18bf52..e8dc69795298 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -12,12 +12,15 @@
 // It is part of the libbitcoinkernel project.
 
 #include <kernel/chainparams.h>
+#include <kernel/chainstatemanager_opts.h>
 #include <kernel/checks.h>
 #include <kernel/context.h>
 #include <kernel/validation_cache_sizes.h>
 
 #include <chainlock/chainlock.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <evo/deterministicmns.h>
@@ -33,15 +36,18 @@
 #include <scheduler.h>
 #include <script/sigcache.h>
 #include <spork.h>
-#include <util/system.h>
+#include <util/chaintype.h>
 #include <util/thread.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <cassert>
+#include <cstdint>
 #include <filesystem>
 #include <functional>
 #include <iosfwd>
+#include <memory>
+#include <string>
 
 int main(int argc, char* argv[])
 {
@@ -57,11 +63,10 @@ int main(int argc, char* argv[])
     }
     std::filesystem::path abs_datadir = std::filesystem::absolute(argv[1]);
     std::filesystem::create_directories(abs_datadir);
-    gArgs.ForceSetArg("-datadir", abs_datadir.string());
 
 
     // SETUP: Misc Globals
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
     auto chainparams = CChainParams::Main();
 
     kernel::Context kernel_context{};
@@ -88,25 +93,49 @@ int main(int argc, char* argv[])
 
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
 
+    class KernelNotifications : public kernel::Notifications
+    {
+    public:
+        void blockTip(SynchronizationState, CBlockIndex&) override
+        {
+            std::cout << "Block tip changed" << std::endl;
+        }
+        void headerTip(SynchronizationState, int64_t height, int64_t timestamp, bool presync) override
+        {
+            std::cout << "Header tip changed: " << height << ", " << timestamp << ", " << presync << std::endl;
+        }
+        void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
+        {
+            std::cout << "Progress: " << title.original << ", " << progress_percent << ", " << resume_possible << std::endl;
+        }
+        void warning(const bilingual_str& warning) override
+        {
+            std::cout << "Warning: " << warning.original << std::endl;
+        }
+    };
+    auto notifications = std::make_unique<KernelNotifications>();
+
 
     // SETUP: Chainstate
     const ChainstateManager::Options chainman_opts{
         .chainparams = *chainparams,
-        .datadir = gArgs.GetDataDirNet(),
+        .datadir = abs_datadir,
+        .notifications = *notifications,
     };
     node::BlockManager::Options blockman_opts{
         .chainparams = chainman_opts.chainparams,
+        .blocks_dir = abs_datadir / "blocks",
     };
     ChainstateManager chainman{chainman_opts, blockman_opts};
 
     CMasternodeMetaMan metaman;
-    CEvoDB evodb{util::DbWrapperParams{.path = gArgs.GetDataDirNet(), .memory = false, .wipe = false}};
+    CEvoDB evodb{util::DbWrapperParams{.path = abs_datadir, .memory = false, .wipe = false}};
     CDeterministicMNManager dmnman{evodb, metaman};
     CSporkManager sporkman;
     chainlock::Chainlocks chainlocks(sporkman);
 
     auto llmq_ctx = WITH_LOCK(::cs_main, return std::make_unique<LLMQContext>(dmnman, evodb, chainman,
-                                                                              util::DbWrapperParams{.path = gArgs.GetDataDirNet(), .memory = false, .wipe = false},
+                                                                              util::DbWrapperParams{.path = abs_datadir, .memory = false, .wipe = false},
                                                                               llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_WORKER_COUNT, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE));
     auto special_tx = std::make_unique<CSpecialTxProcessor>(evodb, dmnman,
                                                             *llmq_ctx->quorum_block_processor, *llmq_ctx->qsnapman,
@@ -119,7 +148,7 @@ int main(int argc, char* argv[])
     cache_sizes.coins = (450 << 20) - (2 << 20) - (2 << 22);
     node::ChainstateLoadOptions options;
     options.chainlocks = &chainlocks;
-    options.data_dir = gArgs.GetDataDirNet();
+    options.data_dir = abs_datadir;
     options.check_interrupt = [] { return false; };
     options.coins_error_cb = [] {};
     auto [status, error] = node::LoadChainstate(chainman, cache_sizes, options, evodb, dmnman, *special_tx);
@@ -145,7 +174,8 @@ int main(int argc, char* argv[])
     // Main program logic starts here
     std::cout
         << "Hello! I'm going to print out some information about your datadir." << std::endl
-        << "\t" << "Path: " << gArgs.GetDataDirNet() << std::endl;
+        << "\t"
+        << "Path: " << abs_datadir << std::endl;
     {
         LOCK(chainman.GetMutex());
         std::cout
diff --git a/src/bitcoin-cli.cpp b/src/bitcoin-cli.cpp
index ed477475189e..91717602a927 100644
--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -10,6 +10,8 @@
 
 #include <chainparamsbase.h>
 #include <clientversion.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <compat/stdin.h>
 #include <policy/feerate.h>
@@ -20,9 +22,10 @@
 #include <stacktraces.h>
 #include <tinyformat.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 #include <util/exception.h>
 #include <util/strencodings.h>
-#include <util/system.h>
+#include <util/time.h>
 #include <util/translation.h>
 
 #include <algorithm>
@@ -71,10 +74,10 @@ static void SetupCliArgs(ArgsManager& argsman)
 {
     SetupHelpOptions(argsman);
 
-    const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);
-    const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
-    const auto devnetBaseParams = CreateBaseChainParams(CBaseChainParams::DEVNET);
-    const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);
+    const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
+    const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
+    const auto devnetBaseParams = CreateBaseChainParams(ChainType::DEVNET);
+    const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
 
     argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-conf=<file>", strprintf("Specify configuration file. Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
@@ -179,7 +182,7 @@ static int AppInitRPC(int argc, char* argv[])
     }
     // Check for chain settings (BaseParams() calls are only valid after this clause)
     try {
-        SelectBaseParams(gArgs.GetChainName());
+        SelectBaseParams(gArgs.GetChainType());
     } catch (const std::exception& e) {
         tfm::format(std::cerr, "Error: %s\n", e.what());
         return EXIT_FAILURE;
@@ -436,10 +439,17 @@ class NetinfoRequestHandler : public BaseRequestHandler
     std::vector<Peer> m_peers;
     std::string ChainToString() const
     {
-        if (gArgs.GetChainName() == CBaseChainParams::TESTNET) return " testnet";
-        if (gArgs.GetChainName() == CBaseChainParams::DEVNET) return " devnet";
-        if (gArgs.GetChainName() == CBaseChainParams::REGTEST) return " regtest";
-        return "";
+        switch (gArgs.GetChainType()) {
+        case ChainType::TESTNET:
+            return " testnet";
+        case ChainType::DEVNET:
+            return " devnet";
+        case ChainType::REGTEST:
+            return " regtest";
+        case ChainType::MAIN:
+            return "";
+        }
+        assert(false);
     }
     std::string PingTimeToString(double seconds) const
     {
@@ -1254,7 +1264,7 @@ MAIN_FUNCTION
     RegisterPrettySignalHandlers();
 
 #ifdef WIN32
-    util::WinCmdLineArgs winArgs;
+    common::WinCmdLineArgs winArgs;
     std::tie(argc, argv) = winArgs.get();
 #endif
     SetupEnvironment();
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 5cff3c7ac2d5..8d7672aeb5c9 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -7,8 +7,11 @@
 #endif
 
 #include <chainparams.h>
+#include <chainparamsbase.h>
 #include <clientversion.h>
 #include <coins.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <consensus/consensus.h>
 #include <core_io.h>
@@ -24,7 +27,6 @@
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <cstdio>
@@ -93,7 +95,7 @@ static int AppInitRawTx(int argc, char* argv[])
 
     // Check for chain settings (Params() calls are only valid after this clause)
     try {
-        SelectParams(gArgs.GetChainName());
+        SelectParams(gArgs.GetChainType());
     } catch (const std::exception& e) {
         tfm::format(std::cerr, "Error: %s\n", e.what());
         return EXIT_FAILURE;
diff --git a/src/bitcoin-util.cpp b/src/bitcoin-util.cpp
index 1637f444a7f6..fd1e7cd004d3 100644
--- a/src/bitcoin-util.cpp
+++ b/src/bitcoin-util.cpp
@@ -11,10 +11,11 @@
 #include <chainparams.h>
 #include <chainparamsbase.h>
 #include <clientversion.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <core_io.h>
 #include <streams.h>
 #include <util/exception.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <atomic>
@@ -71,7 +72,7 @@ static int AppInitUtil(ArgsManager& args, int argc, char* argv[])
 
     // Check for chain settings (Params() calls are only valid after this clause)
     try {
-        SelectParams(args.GetChainName());
+        SelectParams(args.GetChainType());
     } catch (const std::exception& e) {
         tfm::format(std::cerr, "Error: %s\n", e.what());
         return EXIT_FAILURE;
diff --git a/src/bitcoin-wallet.cpp b/src/bitcoin-wallet.cpp
index 8c99ba61a936..94f281e57ab3 100644
--- a/src/bitcoin-wallet.cpp
+++ b/src/bitcoin-wallet.cpp
@@ -8,6 +8,8 @@
 
 #include <chainparams.h>
 #include <chainparamsbase.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <interfaces/init.h>
 #include <logging.h>
@@ -17,7 +19,6 @@
 #include <pubkey.h>
 #include <tinyformat.h>
 #include <util/exception.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <wallet/wallettool.h>
 
@@ -89,7 +90,7 @@ static std::optional<int> WalletAppInit(ArgsManager& args, int argc, char* argv[
         return EXIT_FAILURE;
     }
     // Check for chain settings (Params() calls are only valid after this clause)
-    SelectParams(args.GetChainName());
+    SelectParams(args.GetChainType());
 
     return std::nullopt;
 }
@@ -98,7 +99,7 @@ MAIN_FUNCTION
 {
     ArgsManager& args = gArgs;
 #ifdef WIN32
-    util::WinCmdLineArgs winArgs;
+    common::WinCmdLineArgs winArgs;
     std::tie(argc, argv) = winArgs.get();
 #endif
 
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
index 2584cbd52161..51791eb231f3 100644
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -10,7 +10,9 @@
 
 #include <chainparams.h>
 #include <clientversion.h>
+#include <common/args.h>
 #include <common/init.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <init.h>
 #include <interfaces/chain.h>
@@ -22,7 +24,6 @@
 #include <util/check.h>
 #include <util/exception.h>
 #include <util/syserror.h>
-#include <util/system.h>
 #include <util/strencodings.h>
 #include <util/threadnames.h>
 #include <util/tokenpipe.h>
@@ -252,7 +253,7 @@ MAIN_FUNCTION
     RegisterPrettySignalHandlers();
 
 #ifdef WIN32
-    util::WinCmdLineArgs winArgs;
+    common::WinCmdLineArgs winArgs;
     std::tie(argc, argv) = winArgs.get();
 #endif
 
diff --git a/src/blockencodings.cpp b/src/blockencodings.cpp
index 6fd977856b69..99d7ece5619a 100644
--- a/src/blockencodings.cpp
+++ b/src/blockencodings.cpp
@@ -3,9 +3,10 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <blockencodings.h>
+#include <chainparams.h>
+#include <common/system.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
-#include <chainparams.h>
 #include <crypto/sha256.h>
 #include <crypto/siphash.h>
 #include <logging.h>
@@ -13,7 +14,6 @@
 #include <streams.h>
 #include <txmempool.h>
 #include <validation.h>
-#include <util/system.h>
 
 #include <unordered_map>
 
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 2ebc5eade3a0..7e383a644ba3 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -8,7 +8,7 @@
 #include <random.h>
 
 #include <logging.h>
-#include <util/system.h>
+#include <common/system.h>
 
 #include <algorithm>
 #include <map>
diff --git a/src/chainlock/clsig.cpp b/src/chainlock/clsig.cpp
index a845adaa72e0..9313824eb007 100644
--- a/src/chainlock/clsig.cpp
+++ b/src/chainlock/clsig.cpp
@@ -144,10 +144,10 @@ std::array<uint8_t, CBLSSignature::SerSize> RawChainLockSignature(const std::vec
 }
 
 /** Reads and validates one carrier coinbase. Throws on missing or invalid data. */
-CarrierEntry LoadCarrier(const CBlockIndex* carrier, int carrier_height)
+CarrierEntry LoadCarrier(const node::BlockManager& blockman, const CBlockIndex* carrier, int carrier_height)
 {
     CBlock block;
-    if (!node::ReadBlockFromDisk(block, carrier, Params().GetConsensus()) || block.vtx.empty()) {
+    if (!blockman.ReadBlockFromDisk(block, *carrier) || block.vtx.empty()) {
         throw std::runtime_error("Historical ChainLock block data unavailable");
     }
     // ReadBlockFromDisk checks the header only. The result below is kept for the
@@ -184,7 +184,7 @@ std::optional<CoinbaseChainLock> CoinbaseChainLockReader::Read(int carrier_heigh
     const uint256 carrier_hash = carrier->GetBlockHash();
     CarrierEntry entry;
     if (!GetCarrierCache().Get(carrier_hash, entry)) {
-        entry = LoadCarrier(carrier, carrier_height);
+        entry = LoadCarrier(m_blockman, carrier, carrier_height);
         GetCarrierCache().Insert(carrier_hash, entry);
     }
     if (!entry.has_chainlock) {
diff --git a/src/chainlock/clsig.h b/src/chainlock/clsig.h
index da9346408306..eb53cbb547c9 100644
--- a/src/chainlock/clsig.h
+++ b/src/chainlock/clsig.h
@@ -21,6 +21,10 @@ namespace Consensus {
 struct Params;
 } // namespace Consensus
 
+namespace node {
+class BlockManager;
+} // namespace node
+
 namespace llmq {
 class CQuorumManager;
 enum class VerifyRecSigStatus : uint8_t;
@@ -48,10 +52,11 @@ struct CoinbaseChainLock {
 class CoinbaseChainLockReader
 {
     const CBlockIndex* m_tip;
+    const node::BlockManager& m_blockman;
     std::map<int, std::optional<CoinbaseChainLock>> m_cache;
 
 public:
-    explicit CoinbaseChainLockReader(const CBlockIndex* tip) : m_tip(tip) {}
+    CoinbaseChainLockReader(const CBlockIndex* tip, const node::BlockManager& blockman) : m_tip(tip), m_blockman(blockman) {}
     std::optional<CoinbaseChainLock> Read(int carrier_height);
     /** First certificate at or above minimum_height, limited by maximum_height. */
     std::optional<CoinbaseChainLock> Find(int minimum_height, int maximum_height);
diff --git a/src/chainlock/handler.cpp b/src/chainlock/handler.cpp
index 0c71f072e674..69f2efb47067 100644
--- a/src/chainlock/handler.cpp
+++ b/src/chainlock/handler.cpp
@@ -28,8 +28,9 @@
 
 // Forward declaration to break dependency over node/transaction.h
 namespace node {
+class BlockManager;
 CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
-                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+                               const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
 } // namespace node
 
 using node::GetTransaction;
@@ -359,7 +360,7 @@ void ChainlockHandler::Cleanup()
     LOCK2(mempool.cs, cs); // need mempool.cs due to GetTransaction calls
     for (auto it = txFirstSeenTime.begin(); it != txFirstSeenTime.end();) {
         uint256 hashBlock;
-        if (auto tx = GetTransaction(nullptr, &mempool, it->first, Params().GetConsensus(), hashBlock); !tx) {
+        if (auto tx = GetTransaction(nullptr, &mempool, it->first, hashBlock, m_chainman.m_blockman); !tx) {
             // tx has vanished, probably due to conflicts
             it = txFirstSeenTime.erase(it);
         } else if (!hashBlock.IsNull()) {
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
index 7cf84a184520..121b164c760e 100644
--- a/src/chainlock/signing.cpp
+++ b/src/chainlock/signing.cpp
@@ -18,7 +18,6 @@
 
 #include <thread>
 
-using node::ReadBlockFromDisk;
 
 namespace chainlock {
 ChainLockSigner::ChainLockSigner(const ChainstateManager& chainman, const chainlock::Chainlocks& chainlocks,
@@ -238,7 +237,7 @@ ChainLockSigner::BlockTxs::mapped_type ChainLockSigner::GetBlockTxs(const uint25
                 return nullptr;
             }
             CBlock block;
-            if (!ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+            if (!m_chainman.m_blockman.ReadBlockFromDisk(block, *pindex)) {
                 return nullptr;
             }
 
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index b6bd830ec539..9e06cfb41278 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -10,10 +10,14 @@
 #include <util/std23.h>
 
 #include <arith_uint256.h>
+#include <chainparamsbase.h>
 #include <chainparamsseeds.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <consensus/merkle.h>
 #include <deploymentinfo.h>
-#include <util/system.h>
+#include <logging.h>
+#include <util/chaintype.h>
 #include <versionbits.h>
 
 #include <cassert>
@@ -295,28 +299,31 @@ const CChainParams &Params() {
     return *globalChainParams;
 }
 
-std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain)
 {
-    if (chain == CBaseChainParams::MAIN) {
+    switch (chain) {
+    case ChainType::MAIN:
         return CChainParams::Main();
-    } else if (chain == CBaseChainParams::TESTNET) {
+    case ChainType::TESTNET:
         return CChainParams::TestNet();
-    } else if (chain == CBaseChainParams::DEVNET) {
+    case ChainType::DEVNET: {
         auto opts = CChainParams::DevNetOptions{};
         ReadDevNetArgs(args, opts);
         return CChainParams::DevNet(opts);
-    } else if (chain == CBaseChainParams::REGTEST) {
+    }
+    case ChainType::REGTEST: {
         auto opts = CChainParams::RegTestOptions{};
         ReadRegTestArgs(args, opts);
         return CChainParams::RegTest(opts);
     }
-    throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    }
+    assert(false);
 }
 
-void SelectParams(const std::string& network)
+void SelectParams(const ChainType chain)
 {
-    SelectBaseParams(network);
-    globalChainParams = CreateChainParams(gArgs, network);
+    SelectBaseParams(chain);
+    globalChainParams = CreateChainParams(gArgs, chain);
 }
 
 void SetupChainParamsOptions(ArgsManager& argsman)
diff --git a/src/chainparams.h b/src/chainparams.h
index f787c1bf6a90..e5fc20e6f6f4 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -8,12 +8,12 @@
 
 #include <kernel/chainparams.h>
 
-#include <chainparamsbase.h>
 #include <consensus/params.h>
 #include <llmq/params.h>
 #include <netaddress.h>
 #include <primitives/block.h>
 #include <protocol.h>
+#include <util/chaintype.h>
 #include <util/hash_type.h>
 
 #include <cstdint>
@@ -23,12 +23,12 @@
 #include <unordered_map>
 #include <vector>
 
+class ArgsManager;
+
 /**
  * Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
- * @returns a CChainParams* of the chosen chain.
- * @throws a std::runtime_error if the chain is not supported.
  */
-std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain);
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain);
 
 /**
  * Return the currently selected parameters. This won't change after app
@@ -37,10 +37,9 @@ std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, c
 const CChainParams &Params();
 
 /**
- * Sets the params returned by Params() to those for the given chain name.
- * @throws std::runtime_error when the chain is not supported.
+ * Sets the params returned by Params() to those for the given chain type.
  */
-void SelectParams(const std::string& chain);
+void SelectParams(const ChainType chain);
 
 /**
  *Set the arguments for chainparams
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 1a5fb9a8a4b2..7b03ed912581 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -5,16 +5,12 @@
 
 #include <chainparamsbase.h>
 
+#include <common/args.h>
 #include <tinyformat.h>
-#include <util/system.h>
+#include <util/chaintype.h>
 
 #include <assert.h>
 
-const std::string CBaseChainParams::MAIN = "main";
-const std::string CBaseChainParams::TESTNET = "test";
-const std::string CBaseChainParams::DEVNET = "devnet";
-const std::string CBaseChainParams::REGTEST = "regtest";
-
 void SetupChainParamsBaseOptions(ArgsManager& argsman)
 {
     argsman.AddArg("-chain=<chain>", "Use the chain <chain> (default: main). Allowed values: main, test, devnet, regtest", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
@@ -36,22 +32,23 @@ const CBaseChainParams& BaseParams()
  * Port numbers for incoming Tor connections (9996, 19996, 19796, 19896) have
  * been chosen arbitrarily to keep ranges of used ports tight.
  */
-std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain)
+std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const ChainType chain)
 {
-    if (chain == CBaseChainParams::MAIN)
+    switch (chain) {
+    case ChainType::MAIN:
         return std::make_unique<CBaseChainParams>("", 9998, 9996);
-    else if (chain == CBaseChainParams::TESTNET)
+    case ChainType::TESTNET:
         return std::make_unique<CBaseChainParams>("testnet3", 19998, 19996);
-    else if (chain == CBaseChainParams::DEVNET)
+    case ChainType::DEVNET:
         return std::make_unique<CBaseChainParams>(gArgs.GetDevNetName(), 19798, 19796);
-    else if (chain == CBaseChainParams::REGTEST)
+    case ChainType::REGTEST:
         return std::make_unique<CBaseChainParams>("regtest", 19898, 19896);
-    else
-        throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    }
+    assert(false);
 }
 
-void SelectBaseParams(const std::string& chain)
+void SelectBaseParams(const ChainType chain)
 {
     globalChainBaseParams = CreateBaseChainParams(chain);
-    gArgs.SelectConfigNetwork(chain);
+    gArgs.SelectConfigNetwork(ChainTypeToString(chain));
 }
diff --git a/src/chainparamsbase.h b/src/chainparamsbase.h
index c8f94901b495..89def377cc2c 100644
--- a/src/chainparamsbase.h
+++ b/src/chainparamsbase.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_CHAINPARAMSBASE_H
 #define BITCOIN_CHAINPARAMSBASE_H
 
+#include <util/chaintype.h>
+
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -18,14 +20,6 @@ class ArgsManager;
 class CBaseChainParams
 {
 public:
-    ///@{
-    /** Chain name strings */
-    static const std::string MAIN;
-    static const std::string TESTNET;
-    static const std::string DEVNET;
-    static const std::string REGTEST;
-    ///@}
-
     const std::string& DataDir() const { return strDataDir; }
     uint16_t RPCPort() const { return m_rpc_port; }
     uint16_t OnionServiceTargetPort() const { return m_onion_service_target_port; }
@@ -42,10 +36,8 @@ class CBaseChainParams
 
 /**
  * Creates and returns a std::unique_ptr<CBaseChainParams> of the chosen chain.
- * @returns a CBaseChainParams* of the chosen chain.
- * @throws a std::runtime_error if the chain is not supported.
  */
-std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain);
+std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const ChainType chain);
 
 /**
  *Set the arguments for chainparams
@@ -58,7 +50,7 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman);
  */
 const CBaseChainParams& BaseParams();
 
-/** Sets the params returned by Params() to those for the given network. */
-void SelectBaseParams(const std::string& chain);
+/** Sets the params returned by Params() to those for the given chain. */
+void SelectBaseParams(const ChainType chain);
 
 #endif // BITCOIN_CHAINPARAMSBASE_H
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 8f4cf4b4e558..3ba3b6bdbeba 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -5,6 +5,7 @@
 #include <coinjoin/client.h>
 
 #include <coinjoin/options.h>
+#include <common/args.h>
 #include <evo/deterministicmns.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
@@ -14,6 +15,7 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
+#include <common/system.h>
 #include <core_io.h>
 #include <net.h>
 #include <netmessagemaker.h>
@@ -22,7 +24,6 @@
 #include <util/check.h>
 #include <util/fs_helpers.h>
 #include <util/moneystr.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <version.h>
@@ -1019,7 +1020,7 @@ bool CCoinJoinClientSession::DoAutomaticDenominating(ChainstateManager& chainman
         }
 
         if (m_dmnman.GetListAtChainTip().GetCounts().enabled() == 0 &&
-            Params().NetworkIDString() != CBaseChainParams::REGTEST) {
+            Params().GetChainType() != ChainType::REGTEST) {
             strAutoDenomResult = _("No Masternodes detected.");
             WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::DoAutomaticDenominating -- %s\n", strAutoDenomResult.original);
             return false;
@@ -1299,8 +1300,8 @@ CDeterministicMNCPtr CCoinJoinClientSession::GetRandomNotUsedMasternode()
 
 static int WinnersToSkip()
 {
-    return (Params().NetworkIDString() == CBaseChainParams::DEVNET ||
-            Params().NetworkIDString() == CBaseChainParams::REGTEST)
+    return (Params().GetChainType() == ChainType::DEVNET ||
+            Params().GetChainType() == ChainType::REGTEST)
             ? 1 : 8;
 }
 
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 292e672f0a3f..5fe5de73a1ab 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -11,10 +11,10 @@
 
 #include <chain.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <deploymentstatus.h>
 #include <txmempool.h>
 #include <util/moneystr.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <tinyformat.h>
diff --git a/src/coinjoin/interfaces.cpp b/src/coinjoin/interfaces.cpp
index 5ddb127f4217..80731ac7c60b 100644
--- a/src/coinjoin/interfaces.cpp
+++ b/src/coinjoin/interfaces.cpp
@@ -7,6 +7,7 @@
 #include <coinjoin/client.h>
 #include <coinjoin/options.h>
 #include <coinjoin/walletman.h>
+#include <common/args.h>
 #include <node/context.h>
 #include <util/check.h>
 #include <walletinitinterface.h>
diff --git a/src/coinjoin/options.cpp b/src/coinjoin/options.cpp
index deec629deb00..2dd8a9c63658 100644
--- a/src/coinjoin/options.cpp
+++ b/src/coinjoin/options.cpp
@@ -4,7 +4,8 @@
 
 #include <coinjoin/options.h>
 
-#include <util/system.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <univalue.h>
 
 #include <cassert>
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index b06652025431..b9cbb197e414 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -10,6 +10,7 @@
 #include <masternode/meta.h>
 #include <masternode/sync.h>
 
+#include <common/system.h>
 #include <core_io.h>
 #include <net.h>
 #include <net_processing.h>
@@ -21,7 +22,6 @@
 #include <streams.h>
 #include <txmempool.h>
 #include <util/moneystr.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <univalue.h>
diff --git a/src/util/system.cpp b/src/common/args.cpp
similarity index 59%
rename from src/util/system.cpp
rename to src/common/args.cpp
index 9b246b63de3e..d5ebb8cd4c70 100644
--- a/src/util/system.cpp
+++ b/src/common/args.cpp
@@ -1,82 +1,40 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2022 The Bitcoin 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.
 
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
-#include <util/system.h>
-
-#include <support/allocators/secure.h>
+#include <common/args.h>
 
 #include <chainparamsbase.h>
-#include <ctpl_stl.h>
+#include <common/settings.h>
+#include <logging.h>
 #include <sync.h>
+#include <tinyformat.h>
+#include <univalue.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
 #include <util/strencodings.h>
-#include <util/string.h>
-#include <util/syserror.h>
-#include <util/threadnames.h>
-#include <util/translation.h>
 
-#include <tinyformat.h>
-
-#if (defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__))
-#include <pthread.h>
-#include <pthread_np.h>
+#ifdef WIN32
+#include <codecvt>    /* for codecvt_utf8_utf16 */
+#include <shellapi.h> /* for CommandLineToArgvW */
+#include <shlobj.h>   /* for CSIDL_APPDATA */
 #endif
 
-#ifndef WIN32
 #include <algorithm>
-#include <atomic>
 #include <cassert>
-#include <fcntl.h>
-#include <sched.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-
-#else
-
-#include <codecvt>
-
-#include <shellapi.h>
-#include <shlobj.h>
-#endif
-
-#ifdef HAVE_MALLOPT_ARENA_MAX
-#include <malloc.h>
-#endif
-
-#include <univalue.h>
-
-#include <fstream>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
 #include <map>
-#include <memory>
 #include <optional>
+#include <stdexcept>
 #include <string>
-#include <system_error>
-#include <thread>
-#include <typeinfo>
-
-// Application startup time (used for uptime calculation)
-const int64_t nStartupTime = GetTime();
-
-//Dash only features
-const std::string gCoinJoinName = "CoinJoin";
-
-/**
-    nWalletBackups:
-        1..10   - number of automatic backups to keep
-        0       - disabled by command-line
-        -1      - disabled because of some error during run-time
-        -2      - disabled because wallet was locked and we were not able to replenish keypool
-*/
-int nWalletBackups = 10;
+#include <utility>
+#include <variant>
 
 const char * const BITCOIN_CONF_FILENAME = "dash.conf";
 const char * const BITCOIN_SETTINGS_FILENAME = "settings.json";
@@ -110,12 +68,6 @@ static std::string SettingName(const std::string& arg)
     return arg.size() > 0 && arg[0] == '-' ? arg.substr(1) : arg;
 }
 
-struct KeyInfo {
-    std::string name;
-    std::string section;
-    bool negated{false};
-};
-
 /**
  * Parse "name", "section.name", "noname", "section.noname" settings keys.
  *
@@ -152,8 +104,8 @@ KeyInfo InterpretKey(std::string key)
  * @return parsed settings value if it is valid, otherwise nullopt accompanied
  * by a descriptive error string
  */
-static std::optional<util::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
-                                                         unsigned int flags, std::string& error)
+std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
+                                                  unsigned int flags, std::string& error)
 {
     // Return negated settings as false values.
     if (key.negated) {
@@ -191,7 +143,7 @@ std::set<std::string> ArgsManager::GetUnsuitableSectionOnlyArgs() const
     if (m_network.empty()) return std::set<std::string> {};
 
     // if it's okay to use the default section for this network, don't worry
-    if (m_network == CBaseChainParams::MAIN) return std::set<std::string> {};
+    if (m_network == ChainTypeToString(ChainType::MAIN)) return std::set<std::string> {};
 
     for (const auto& arg : m_network_only_args) {
         if (OnlyHasDefaultSectionSetting(m_settings, m_network, SettingName(arg))) {
@@ -205,10 +157,10 @@ std::list<SectionInfo> ArgsManager::GetUnrecognizedSections() const
 {
     // Section names to be recognized in the config file.
     static const std::set<std::string> available_sections{
-        CBaseChainParams::REGTEST,
-        CBaseChainParams::DEVNET,
-        CBaseChainParams::TESTNET,
-        CBaseChainParams::MAIN,
+        ChainTypeToString(ChainType::REGTEST),
+        ChainTypeToString(ChainType::DEVNET),
+        ChainTypeToString(ChainType::TESTNET),
+        ChainTypeToString(ChainType::MAIN),
     };
 
     LOCK(cs_args);
@@ -217,7 +169,7 @@ std::list<SectionInfo> ArgsManager::GetUnrecognizedSections() const
     return unrecognized;
 }
 
-std::map<std::string, std::vector<util::SettingsValue>> ArgsManager::GetCommandLineArgs() const {
+std::map<std::string, std::vector<common::SettingsValue>> ArgsManager::GetCommandLineArgs() const {
     LOCK(cs_args);
     return m_settings.command_line_options;
 }
@@ -291,15 +243,15 @@ bool ArgsManager::ParseParameters(int argc, const char* const argv[], std::strin
             return false;
         }
 
-        std::optional<util::SettingsValue> value = InterpretValue(keyinfo, val ? &*val : nullptr, *flags, error);
+        std::optional<common::SettingsValue> value = InterpretValue(keyinfo, val ? &*val : nullptr, *flags, error);
         if (!value) return false;
 
         m_settings.command_line_options[keyinfo.name].push_back(*value);
     }
 
     // we do not allow -includeconf from command line, only -noincludeconf
-    if (auto* includes = util::FindKey(m_settings.command_line_options, "includeconf")) {
-        const util::SettingsSpan values{*includes};
+    if (auto* includes = common::FindKey(m_settings.command_line_options, "includeconf")) {
+        const common::SettingsSpan values{*includes};
         // Range may be empty if -noincludeconf was passed
         if (!values.empty()) {
             error = "-includeconf cannot be used from commandline; -includeconf=" + values.begin()->write();
@@ -421,7 +373,7 @@ std::optional<const ArgsManager::Command> ArgsManager::GetCommand() const
 std::vector<std::string> ArgsManager::GetArgs(const std::string& strArg) const
 {
     std::vector<std::string> result;
-    for (const util::SettingsValue& value : GetSettingsList(strArg)) {
+    for (const common::SettingsValue& value : GetSettingsList(strArg)) {
         result.push_back(value.isFalse() ? "0" : value.isTrue() ? "1" : value.get_str());
     }
     return result;
@@ -468,7 +420,7 @@ bool ArgsManager::ReadSettingsFile(std::vector<std::string>* errors)
     LOCK(cs_args);
     m_settings.rw_settings.clear();
     std::vector<std::string> read_errors;
-    if (!util::ReadSettings(path, m_settings.rw_settings, read_errors)) {
+    if (!common::ReadSettings(path, m_settings.rw_settings, read_errors)) {
         SaveErrors(read_errors, errors);
         return false;
     }
@@ -490,7 +442,7 @@ bool ArgsManager::WriteSettingsFile(std::vector<std::string>* errors, bool backu
 
     LOCK(cs_args);
     std::vector<std::string> write_errors;
-    if (!util::WriteSettings(path_tmp, m_settings.rw_settings, write_errors)) {
+    if (!common::WriteSettings(path_tmp, m_settings.rw_settings, write_errors)) {
         SaveErrors(write_errors, errors);
         return false;
     }
@@ -501,11 +453,11 @@ bool ArgsManager::WriteSettingsFile(std::vector<std::string>* errors, bool backu
     return true;
 }
 
-util::SettingsValue ArgsManager::GetPersistentSetting(const std::string& name) const
+common::SettingsValue ArgsManager::GetPersistentSetting(const std::string& name) const
 {
     LOCK(cs_args);
-    return util::GetSetting(m_settings, m_network, name, !UseDefaultSection("-" + name),
-        /*ignore_nonpersistent=*/true, /*get_chain_name=*/false);
+    return common::GetSetting(m_settings, m_network, name, !UseDefaultSection("-" + name),
+        /*ignore_nonpersistent=*/true, /*get_chain_type=*/false);
 }
 
 bool ArgsManager::IsArgNegated(const std::string& strArg) const
@@ -520,11 +472,11 @@ std::string ArgsManager::GetArg(const std::string& strArg, const std::string& st
 
 std::optional<std::string> ArgsManager::GetArg(const std::string& strArg) const
 {
-    const util::SettingsValue value = GetSetting(strArg);
+    const common::SettingsValue value = GetSetting(strArg);
     return SettingToString(value);
 }
 
-std::optional<std::string> SettingToString(const util::SettingsValue& value)
+std::optional<std::string> SettingToString(const common::SettingsValue& value)
 {
     if (value.isNull()) return std::nullopt;
     if (value.isFalse()) return "0";
@@ -533,7 +485,7 @@ std::optional<std::string> SettingToString(const util::SettingsValue& value)
     return value.get_str();
 }
 
-std::string SettingToString(const util::SettingsValue& value, const std::string& strDefault)
+std::string SettingToString(const common::SettingsValue& value, const std::string& strDefault)
 {
     return SettingToString(value).value_or(strDefault);
 }
@@ -545,11 +497,11 @@ int64_t ArgsManager::GetIntArg(const std::string& strArg, int64_t nDefault) cons
 
 std::optional<int64_t> ArgsManager::GetIntArg(const std::string& strArg) const
 {
-    const util::SettingsValue value = GetSetting(strArg);
+    const common::SettingsValue value = GetSetting(strArg);
     return SettingToInt(value);
 }
 
-std::optional<int64_t> SettingToInt(const util::SettingsValue& value)
+std::optional<int64_t> SettingToInt(const common::SettingsValue& value)
 {
     if (value.isNull()) return std::nullopt;
     if (value.isFalse()) return 0;
@@ -558,7 +510,7 @@ std::optional<int64_t> SettingToInt(const util::SettingsValue& value)
     return LocaleIndependentAtoi<int64_t>(value.get_str());
 }
 
-int64_t SettingToInt(const util::SettingsValue& value, int64_t nDefault)
+int64_t SettingToInt(const common::SettingsValue& value, int64_t nDefault)
 {
     return SettingToInt(value).value_or(nDefault);
 }
@@ -570,18 +522,18 @@ bool ArgsManager::GetBoolArg(const std::string& strArg, bool fDefault) const
 
 std::optional<bool> ArgsManager::GetBoolArg(const std::string& strArg) const
 {
-    const util::SettingsValue value = GetSetting(strArg);
+    const common::SettingsValue value = GetSetting(strArg);
     return SettingToBool(value);
 }
 
-std::optional<bool> SettingToBool(const util::SettingsValue& value)
+std::optional<bool> SettingToBool(const common::SettingsValue& value)
 {
     if (value.isNull()) return std::nullopt;
     if (value.isBool()) return value.get_bool();
     return InterpretBool(value.get_str());
 }
 
-bool SettingToBool(const util::SettingsValue& value, bool fDefault)
+bool SettingToBool(const common::SettingsValue& value, bool fDefault)
 {
     return SettingToBool(value).value_or(fDefault);
 }
@@ -743,9 +695,9 @@ void ArgsManager::ForceRemoveArg(const std::string& strArg)
         m_settings.forced_settings.erase(ov);
     }
 
-    for (const auto& network : { CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::REGTEST, CBaseChainParams::DEVNET }) {
-        if (auto* section = util::FindKey(m_settings.ro_config, network)) {
-            if (util::FindKey(*section, strArg)) {
+    for (const auto& network : { ChainType::MAIN, ChainType::TESTNET, ChainType::REGTEST, ChainType::DEVNET }) {
+        if (auto* section = common::FindKey(m_settings.ro_config, ChainTypeToString(network))) {
+            if (common::FindKey(*section, strArg)) {
                 section->erase(strArg);
             }
         }
@@ -814,222 +766,54 @@ bool CheckDataDirOption(const ArgsManager& args)
     return datadir.empty() || fs::is_directory(fs::absolute(datadir));
 }
 
-static bool GetConfigOptions(std::istream& stream, const std::string& filepath, std::string& error, std::vector<std::pair<std::string, std::string>>& options, std::list<SectionInfo>& sections)
-{
-    std::string str, prefix;
-    std::string::size_type pos;
-    int linenr = 1;
-    while (std::getline(stream, str)) {
-        bool used_hash = false;
-        if ((pos = str.find('#')) != std::string::npos) {
-            str = str.substr(0, pos);
-            used_hash = true;
-        }
-        const static std::string pattern = " \t\r\n";
-        str = TrimString(str, pattern);
-        if (!str.empty()) {
-            if (*str.begin() == '[' && *str.rbegin() == ']') {
-                const std::string section = str.substr(1, str.size() - 2);
-                sections.emplace_back(SectionInfo{section, filepath, linenr});
-                prefix = section + '.';
-            } else if (*str.begin() == '-') {
-                error = strprintf("parse error on line %i: %s, options in configuration file must be specified without leading -", linenr, str);
-                return false;
-            } else if ((pos = str.find('=')) != std::string::npos) {
-                std::string name = prefix + TrimString(std::string_view{str}.substr(0, pos), pattern);
-                std::string_view value = TrimStringView(std::string_view{str}.substr(pos + 1), pattern);
-                if (used_hash && name.find("rpcpassword") != std::string::npos) {
-                    error = strprintf("parse error on line %i, using # in rpcpassword can be ambiguous and should be avoided", linenr);
-                    return false;
-                }
-                options.emplace_back(name, value);
-                if ((pos = name.rfind('.')) != std::string::npos && prefix.length() <= pos) {
-                    sections.emplace_back(SectionInfo{name.substr(0, pos), filepath, linenr});
-                }
-            } else {
-                error = strprintf("parse error on line %i: %s", linenr, str);
-                if (str.size() >= 2 && str.substr(0, 2) == "no") {
-                    error += strprintf(", if you intended to specify a negated option, use %s=1 instead", str);
-                }
-                return false;
-            }
-        }
-        ++linenr;
-    }
-    return true;
-}
-
-bool IsConfSupported(KeyInfo& key, std::string& error) {
-    if (key.name == "conf") {
-        error = "conf cannot be set in the configuration file; use includeconf= if you want to include additional config files";
-        return false;
-    }
-    if (key.name == "reindex") {
-        // reindex can be set in a config file but it is strongly discouraged as this will cause the node to reindex on
-        // every restart. Allow the config but throw a warning
-        LogPrintf("Warning: reindex=1 is set in the configuration file, which will significantly slow down startup. Consider removing or commenting out this option for better performance, unless there is currently a condition which makes rebuilding the indexes necessary\n");
-        return true;
-    }
-    return true;
-}
-
-bool ArgsManager::ReadConfigStream(std::istream& stream, const std::string& filepath, std::string& error, bool ignore_invalid_keys)
-{
-    LOCK(cs_args);
-    std::vector<std::pair<std::string, std::string>> options;
-    if (!GetConfigOptions(stream, filepath, error, options, m_config_sections)) {
-        return false;
-    }
-    for (const std::pair<std::string, std::string>& option : options) {
-        KeyInfo key = InterpretKey(option.first);
-        std::optional<unsigned int> flags = GetArgFlags('-' + key.name);
-        if (!IsConfSupported(key, error)) return false;
-        if (flags) {
-            std::optional<util::SettingsValue> value = InterpretValue(key, &option.second, *flags, error);
-            if (!value) {
-                return false;
-            }
-            m_settings.ro_config[key.section][key.name].push_back(*value);
-        } else {
-            if (ignore_invalid_keys) {
-                LogPrintf("Ignoring unknown configuration value %s\n", option.first);
-            } else {
-                error = strprintf("Invalid configuration value %s", option.first);
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
 fs::path ArgsManager::GetConfigFilePath() const
 {
     LOCK(cs_args);
     return *Assert(m_config_path);
 }
 
-bool ArgsManager::ReadConfigFiles(std::string& error, bool ignore_invalid_keys)
+ChainType ArgsManager::GetChainType() const
 {
-    {
-        LOCK(cs_args);
-        m_settings.ro_config.clear();
-        m_config_sections.clear();
-        m_config_path = AbsPathForConfigVal(*this, GetPathArg("-conf", BITCOIN_CONF_FILENAME), /*net_specific=*/false);
-    }
-
-    const auto conf_path{GetConfigFilePath()};
-    std::ifstream stream{conf_path};
-
-    // not ok to have a config file specified that cannot be opened
-    if (IsArgSet("-conf") && !stream.good()) {
-        error = strprintf("specified config file \"%s\" could not be opened.", fs::PathToString(conf_path));
-        return false;
-    }
-    // ok to not have a config file
-    if (stream.good()) {
-        if (!ReadConfigStream(stream, fs::PathToString(conf_path), error, ignore_invalid_keys)) {
-            return false;
-        }
-        // `-includeconf` cannot be included in the command line arguments except
-        // as `-noincludeconf` (which indicates that no included conf file should be used).
-        bool use_conf_file{true};
-        {
-            LOCK(cs_args);
-            if (auto* includes = util::FindKey(m_settings.command_line_options, "includeconf")) {
-                // ParseParameters() fails if a non-negated -includeconf is passed on the command-line
-                assert(util::SettingsSpan(*includes).last_negated());
-                use_conf_file = false;
-            }
-        }
-        if (use_conf_file) {
-            std::string chain_id = GetChainName();
-            std::vector<std::string> conf_file_names;
-
-            auto add_includes = [&](const std::string& network, size_t skip = 0) {
-                size_t num_values = 0;
-                LOCK(cs_args);
-                if (auto* section = util::FindKey(m_settings.ro_config, network)) {
-                    if (auto* values = util::FindKey(*section, "includeconf")) {
-                        for (size_t i = std::max(skip, util::SettingsSpan(*values).negated()); i < values->size(); ++i) {
-                            conf_file_names.push_back((*values)[i].get_str());
-                        }
-                        num_values = values->size();
-                    }
-                }
-                return num_values;
-            };
-
-            // We haven't set m_network yet (that happens in SelectParams()), so manually check
-            // for network.includeconf args.
-            const size_t chain_includes = add_includes(chain_id);
-            const size_t default_includes = add_includes({});
-
-            for (const std::string& conf_file_name : conf_file_names) {
-                std::ifstream conf_file_stream{AbsPathForConfigVal(*this, fs::PathFromString(conf_file_name), /*net_specific=*/false)};
-                if (conf_file_stream.good()) {
-                    if (!ReadConfigStream(conf_file_stream, conf_file_name, error, ignore_invalid_keys)) {
-                        return false;
-                    }
-                    LogPrintf("Included configuration file %s\n", conf_file_name);
-                } else {
-                    error = "Failed to include configuration file " + conf_file_name;
-                    return false;
-                }
-            }
-
-            // Warn about recursive -includeconf
-            conf_file_names.clear();
-            add_includes(chain_id, /* skip= */ chain_includes);
-            add_includes({}, /* skip= */ default_includes);
-            std::string chain_id_final = GetChainName();
-            if (chain_id_final != chain_id) {
-                // Also warn about recursive includeconf for the chain that was specified in one of the includeconfs
-                add_includes(chain_id_final);
-            }
-            for (const std::string& conf_file_name : conf_file_names) {
-                tfm::format(std::cerr, "warning: -includeconf cannot be used from included files; ignoring -includeconf=%s\n", conf_file_name);
-            }
-        }
-    }
+    std::variant<ChainType, std::string> arg = GetChainArg();
+    if (auto* parsed = std::get_if<ChainType>(&arg)) return *parsed;
+    throw std::runtime_error(strprintf("Unknown chain %s.", std::get<std::string>(arg)));
+}
 
-    // If datadir is changed in .conf file:
-    ClearPathCache();
-    if (!CheckDataDirOption(*this)) {
-        error = strprintf("specified data directory \"%s\" does not exist.", GetArg("-datadir", ""));
-        return false;
-    }
-    return true;
+std::string ArgsManager::GetChainTypeString() const
+{
+    auto arg = GetChainArg();
+    if (auto* parsed = std::get_if<ChainType>(&arg)) return ChainTypeToString(*parsed);
+    return std::get<std::string>(arg);
 }
 
-std::string ArgsManager::GetChainName() const
+std::variant<ChainType, std::string> ArgsManager::GetChainArg() const
 {
     auto get_net = [&](const std::string& arg, bool interpret_bool = true) {
         LOCK(cs_args);
-        util::SettingsValue value = util::GetSetting(m_settings, /* section= */ "", SettingName(arg),
+        common::SettingsValue value = common::GetSetting(m_settings, /* section= */ "", SettingName(arg),
             /* ignore_default_section_config= */ false,
             /*ignore_nonpersistent=*/false,
-            /* get_chain_name= */ true);
+            /* get_chain_type= */ true);
         return value.isNull() ? false : value.isBool() ? value.get_bool() : (!interpret_bool || InterpretBool(value.get_str()));
     };
 
     const bool fRegTest = get_net("-regtest");
     const bool fDevNet = get_net("-devnet", false);
     const bool fTestNet = get_net("-testnet");
-    const bool is_chain_arg_set = IsArgSet("-chain");
+    const auto chain_arg = GetArg("-chain");
 
-    int nameParamsCount = (fRegTest ? 1 : 0) + (fDevNet ? 1 : 0) + (fTestNet ? 1 : 0) + (is_chain_arg_set ? 1 : 0);
-    if (nameParamsCount > 1)
+    if ((int)chain_arg.has_value() + (int)fRegTest + (int)fDevNet + (int)fTestNet > 1) {
         throw std::runtime_error("Only one of -regtest, -testnet, -devnet or -chain can be used.");
-
-    if (fRegTest)
-        return CBaseChainParams::REGTEST;
-    if (fDevNet) {
-        return CBaseChainParams::DEVNET;
     }
-    if (fTestNet)
-        return CBaseChainParams::TESTNET;
-
-    return GetArg("-chain", CBaseChainParams::MAIN);
+    if (chain_arg) {
+        if (auto parsed = ChainTypeFromString(*chain_arg)) return *parsed;
+        // Not a known string, so return original string
+        return *chain_arg;
+    }
+    if (fRegTest) return ChainType::REGTEST;
+    if (fDevNet) return ChainType::DEVNET;
+    if (fTestNet) return ChainType::TESTNET;
+    return ChainType::MAIN;
 }
 
 std::string ArgsManager::GetDevNetName() const
@@ -1042,7 +826,7 @@ std::string ArgsManager::GetDevNetName() const
 void ArgsManager::logArgsPrefix(
     const std::string& prefix,
     const std::string& section,
-    const std::map<std::string, std::vector<util::SettingsValue>>& args) const
+    const std::map<std::string, std::vector<common::SettingsValue>>& args) const
 {
     std::string section_str = section.empty() ? "" : "[" + section + "] ";
     for (const auto& arg : args) {
@@ -1070,159 +854,24 @@ void ArgsManager::LogArgs() const
 
 bool ArgsManager::UseDefaultSection(const std::string& arg) const
 {
-    return m_network == CBaseChainParams::MAIN || m_network_only_args.count(arg) == 0;
+    return m_network == ChainTypeToString(ChainType::MAIN) || m_network_only_args.count(arg) == 0;
 }
 
-util::SettingsValue ArgsManager::GetSetting(const std::string& arg) const
+common::SettingsValue ArgsManager::GetSetting(const std::string& arg) const
 {
     LOCK(cs_args);
-    return util::GetSetting(
+    return common::GetSetting(
         m_settings, m_network, SettingName(arg), !UseDefaultSection(arg),
-        /*ignore_nonpersistent=*/false, /*get_chain_name=*/false);
+        /*ignore_nonpersistent=*/false, /*get_chain_type=*/false);
 }
 
-std::vector<util::SettingsValue> ArgsManager::GetSettingsList(const std::string& arg) const
+std::vector<common::SettingsValue> ArgsManager::GetSettingsList(const std::string& arg) const
 {
     LOCK(cs_args);
-    return util::GetSettingsList(m_settings, m_network, SettingName(arg), !UseDefaultSection(arg));
-}
-
-#ifndef WIN32
-std::string ShellEscape(const std::string& arg)
-{
-    std::string escaped = arg;
-    ReplaceAll(escaped, "'", "'\"'\"'");
-    return "'" + escaped + "'";
-}
-#endif
-
-#if HAVE_SYSTEM
-void runCommand(const std::string& strCommand)
-{
-    if (strCommand.empty()) return;
-#ifndef WIN32
-    int nErr = ::system(strCommand.c_str());
-#else
-    int nErr = ::_wsystem(std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>,wchar_t>().from_bytes(strCommand).c_str());
-#endif
-    if (nErr)
-        LogPrintf("runCommand error: system(%s) returned %d\n", strCommand, nErr);
-}
-#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
-    // glibc-specific: On 32-bit systems set the number of arenas to 1.
-    // By default, since glibc 2.10, the C library will create up to two heap
-    // arenas per core. This is known to cause excessive virtual address space
-    // usage in our usage. Work around it by setting the maximum number of
-    // arenas to 1.
-    if (sizeof(void*) == 4) {
-        mallopt(M_ARENA_MAX, 1);
-    }
-#endif
-    // On most POSIX systems (e.g. Linux, but not BSD) the environment's locale
-    // may be invalid, in which case the "C.UTF-8" locale is used as fallback.
-#if !defined(WIN32) && !defined(MAC_OSX) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-    try {
-        std::locale(""); // Raises a runtime error if current locale is invalid
-    } catch (const std::runtime_error&) {
-        setenv("LC_ALL", "C.UTF-8", 1);
-    }
-#elif defined(WIN32)
-    // Set the default input/output charset is utf-8
-    SetConsoleCP(CP_UTF8);
-    SetConsoleOutputCP(CP_UTF8);
-#endif
-
-#ifndef WIN32
-    constexpr mode_t private_umask = 0077;
-    umask(private_umask);
-#endif
-}
-
-bool SetupNetworking()
-{
-#ifdef WIN32
-    // Initialize Windows Sockets
-    WSADATA wsadata;
-    int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
-    if (ret != NO_ERROR || LOBYTE(wsadata.wVersion ) != 2 || HIBYTE(wsadata.wVersion) != 2)
-        return false;
-#endif
-    return true;
-}
-
-int GetNumCores()
-{
-    return std::thread::hardware_concurrency();
-}
-
-// Obtain the application startup time (used for uptime calculation)
-int64_t GetStartupTime()
-{
-    return nStartupTime;
-}
-
-fs::path AbsPathForConfigVal(const ArgsManager& args, const fs::path& path, bool net_specific)
-{
-    if (path.is_absolute()) {
-        return path;
-    }
-    return fsbridge::AbsPathJoin(net_specific ? args.GetDataDirNet() : args.GetDataDirBase(), path);
-}
-
-void ScheduleBatchPriority()
-{
-#ifdef SCHED_BATCH
-    const static sched_param param{};
-    const int rc = pthread_setschedparam(pthread_self(), SCHED_BATCH, &param);
-    if (rc != 0) {
-        LogPrintf("Failed to pthread_setschedparam: %s\n", SysErrorString(rc));
-    }
-#endif
+    return common::GetSettingsList(m_settings, m_network, SettingName(arg), !UseDefaultSection(arg));
 }
 
-namespace util {
+namespace common {
 #ifdef WIN32
 WinCmdLineArgs::WinCmdLineArgs()
 {
@@ -1247,4 +896,4 @@ std::pair<int, char**> WinCmdLineArgs::get()
     return std::make_pair(argc, argv);
 }
 #endif
-} // namespace util
+} // namespace common
diff --git a/src/util/system.h b/src/common/args.h
similarity index 82%
rename from src/util/system.h
rename to src/common/args.h
index 655b0802a443..0fbdfe9af687 100644
--- a/src/util/system.h
+++ b/src/common/args.h
@@ -1,62 +1,33 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
-// Copyright (c) 2014-2025 The Dash Core developers
+// Copyright (c) 2023 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-/**
- * Server/client environment: argument handling, config file parsing,
- * thread wrappers, startup time
- */
-#ifndef BITCOIN_UTIL_SYSTEM_H
-#define BITCOIN_UTIL_SYSTEM_H
+#ifndef BITCOIN_COMMON_ARGS_H
+#define BITCOIN_COMMON_ARGS_H
 
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
-#include <compat/assumptions.h>
+#include <common/settings.h>
 #include <compat/compat.h>
-#include <consensus/amount.h>
-#include <logging.h>
 #include <sync.h>
+#include <util/chaintype.h>
 #include <util/fs.h>
-#include <util/settings.h>
-#include <util/time.h>
 
+#include <iosfwd>
+#include <list>
 #include <map>
 #include <optional>
 #include <set>
 #include <stdint.h>
 #include <string>
-#include <utility>
+#include <variant>
 #include <vector>
 
-//Dash only features
-
-extern int nWalletBackups;
-extern const std::string gCoinJoinName;
-
 class ArgsManager;
-class UniValue;
-
-// Application startup time (used for uptime calculation)
-int64_t GetStartupTime();
 
 extern const char * const BITCOIN_CONF_FILENAME;
 extern const char * const BITCOIN_SETTINGS_FILENAME;
 
-void SetupEnvironment();
-[[nodiscard]] bool SetupNetworking();
-
 // Return true if -datadir option points to a valid directory or is not specified.
 bool CheckDataDirOption(const ArgsManager& args);
-#ifndef WIN32
-std::string ShellEscape(const std::string& arg);
-#endif
-#if HAVE_SYSTEM
-void runCommand(const std::string& strCommand);
-#endif
 
 /**
  * Most paths passed as configuration arguments are treated as relative to
@@ -102,21 +73,31 @@ enum class OptionsCategory {
     HIDDEN // Always the last option to avoid printing these in the help
 };
 
-struct SectionInfo
-{
+struct KeyInfo {
+    std::string name;
+    std::string section;
+    bool negated{false};
+};
+
+KeyInfo InterpretKey(std::string key);
+
+std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
+                                                         unsigned int flags, std::string& error);
+
+struct SectionInfo {
     std::string m_name;
     std::string m_file;
     int m_line;
 };
 
-std::string SettingToString(const util::SettingsValue&, const std::string&);
-std::optional<std::string> SettingToString(const util::SettingsValue&);
+std::string SettingToString(const common::SettingsValue&, const std::string&);
+std::optional<std::string> SettingToString(const common::SettingsValue&);
 
-int64_t SettingToInt(const util::SettingsValue&, int64_t);
-std::optional<int64_t> SettingToInt(const util::SettingsValue&);
+int64_t SettingToInt(const common::SettingsValue&, int64_t);
+std::optional<int64_t> SettingToInt(const common::SettingsValue&);
 
-bool SettingToBool(const util::SettingsValue&, bool);
-std::optional<bool> SettingToBool(const util::SettingsValue&);
+bool SettingToBool(const common::SettingsValue&, bool);
+std::optional<bool> SettingToBool(const common::SettingsValue&);
 
 class ArgsManager
 {
@@ -155,7 +136,7 @@ class ArgsManager
     };
 
     mutable RecursiveMutex cs_args;
-    util::Settings m_settings GUARDED_BY(cs_args);
+    common::Settings m_settings GUARDED_BY(cs_args);
     std::vector<std::string> m_command GUARDED_BY(cs_args);
     std::string m_network GUARDED_BY(cs_args);
     std::set<std::string> m_network_only_args GUARDED_BY(cs_args);
@@ -184,12 +165,12 @@ class ArgsManager
      * false if "-nosetting" argument was passed, and a string if a "-setting=value"
      * argument was passed.
      */
-    util::SettingsValue GetSetting(const std::string& arg) const;
+    common::SettingsValue GetSetting(const std::string& arg) const;
 
     /**
      * Get list of setting values.
      */
-    std::vector<util::SettingsValue> GetSettingsList(const std::string& arg) const;
+    std::vector<common::SettingsValue> GetSettingsList(const std::string& arg) const;
 
     ArgsManager();
     ~ArgsManager();
@@ -237,7 +218,7 @@ class ArgsManager
     /**
      * Return the map of all the args passed via the command line
      */
-    std::map<std::string, std::vector<util::SettingsValue>> GetCommandLineArgs() const;
+    std::map<std::string, std::vector<common::SettingsValue>> GetCommandLineArgs() const;
 
     /**
      * Get blocks directory path
@@ -358,10 +339,18 @@ class ArgsManager
     void ForceRemoveArg(const std::string& strArg);
 
     /**
-     * Returns the appropriate chain name from the program arguments.
-     * @return CBaseChainParams::MAIN by default; raises runtime error if an invalid combination is given.
+     * Returns the appropriate chain type from the program arguments.
+     * @return ChainType::MAIN by default; raises runtime error if an invalid
+     * combination, or unknown chain is given.
+     */
+    ChainType GetChainType() const;
+
+    /**
+     * Returns the appropriate chain type string from the program arguments.
+     * @return ChainType::MAIN string by default; raises runtime error if an
+     * invalid combination is given.
      */
-    std::string GetChainName() const;
+    std::string GetChainTypeString() const;
 
     /**
      * Looks for -devnet and returns either "devnet-<name>" or simply "devnet" if no name was specified.
@@ -426,7 +415,7 @@ class ArgsManager
      * Get current setting from config file or read/write settings file,
      * ignoring nonpersistent command line or forced settings values.
      */
-    util::SettingsValue GetPersistentSetting(const std::string& name) const;
+    common::SettingsValue GetPersistentSetting(const std::string& name) const;
 
     /**
      * Access settings with lock held.
@@ -453,11 +442,19 @@ class ArgsManager
      */
     fs::path GetDataDir(bool net_specific) const;
 
+    /**
+     * Return -regtest/-signet/-testnet/-chain= setting as a ChainType enum if a
+     * recognized chain type was set, or as a string if an unrecognized chain
+     * name was set. Raise an exception if an invalid combination of flags was
+     * provided.
+     */
+    std::variant<ChainType, std::string> GetChainArg() const;
+
     // Helper function for LogArgs().
     void logArgsPrefix(
         const std::string& prefix,
         const std::string& section,
-        const std::map<std::string, std::vector<util::SettingsValue>>& args) const;
+        const std::map<std::string, std::vector<common::SettingsValue>>& args) const;
 };
 
 extern ArgsManager gArgs;
@@ -487,36 +484,7 @@ std::string HelpMessageGroup(const std::string& message);
  */
 std::string HelpMessageOpt(const std::string& option, const std::string& message);
 
-/**
- * Return the number of cores available on the current system.
- * @note This does count virtual cores, such as those provided by HyperThreading.
- */
-int GetNumCores();
-
-namespace ctpl {
-    class thread_pool;
-}
-void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName);
-
-/**
- * On platforms that support it, tell the kernel the calling thread is
- * CPU-intensive and non-interactive. See SCHED_BATCH in sched(7) for details.
- *
- */
-void ScheduleBatchPriority();
-
-namespace util {
-
-//! Simplification of std insertion
-template <typename Tdst, typename Tsrc>
-inline void insert(Tdst& dst, const Tsrc& src) {
-    dst.insert(dst.begin(), src.begin(), src.end());
-}
-template <typename TsetT, typename Tsrc>
-inline void insert(std::set<TsetT>& dst, const Tsrc& src) {
-    dst.insert(src.begin(), src.end());
-}
-
+namespace common {
 #ifdef WIN32
 class WinCmdLineArgs
 {
@@ -531,7 +499,6 @@ class WinCmdLineArgs
     std::vector<std::string> args;
 };
 #endif
+} // namespace common
 
-} // namespace util
-
-#endif // BITCOIN_UTIL_SYSTEM_H
+#endif // BITCOIN_COMMON_ARGS_H
diff --git a/src/common/config.cpp b/src/common/config.cpp
new file mode 100644
index 000000000000..1c85273f69c6
--- /dev/null
+++ b/src/common/config.cpp
@@ -0,0 +1,217 @@
+// Copyright (c) 2023 The Bitcoin 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 <common/settings.h>
+#include <logging.h>
+#include <sync.h>
+#include <tinyformat.h>
+#include <univalue.h>
+#include <util/chaintype.h>
+#include <util/fs.h>
+#include <util/string.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+static bool GetConfigOptions(std::istream& stream, const std::string& filepath, std::string& error, std::vector<std::pair<std::string, std::string>>& options, std::list<SectionInfo>& sections)
+{
+    std::string str, prefix;
+    std::string::size_type pos;
+    int linenr = 1;
+    while (std::getline(stream, str)) {
+        bool used_hash = false;
+        if ((pos = str.find('#')) != std::string::npos) {
+            str = str.substr(0, pos);
+            used_hash = true;
+        }
+        const static std::string pattern = " \t\r\n";
+        str = TrimString(str, pattern);
+        if (!str.empty()) {
+            if (*str.begin() == '[' && *str.rbegin() == ']') {
+                const std::string section = str.substr(1, str.size() - 2);
+                sections.emplace_back(SectionInfo{section, filepath, linenr});
+                prefix = section + '.';
+            } else if (*str.begin() == '-') {
+                error = strprintf("parse error on line %i: %s, options in configuration file must be specified without leading -", linenr, str);
+                return false;
+            } else if ((pos = str.find('=')) != std::string::npos) {
+                std::string name = prefix + TrimString(std::string_view{str}.substr(0, pos), pattern);
+                std::string_view value = TrimStringView(std::string_view{str}.substr(pos + 1), pattern);
+                if (used_hash && name.find("rpcpassword") != std::string::npos) {
+                    error = strprintf("parse error on line %i, using # in rpcpassword can be ambiguous and should be avoided", linenr);
+                    return false;
+                }
+                options.emplace_back(name, value);
+                if ((pos = name.rfind('.')) != std::string::npos && prefix.length() <= pos) {
+                    sections.emplace_back(SectionInfo{name.substr(0, pos), filepath, linenr});
+                }
+            } else {
+                error = strprintf("parse error on line %i: %s", linenr, str);
+                if (str.size() >= 2 && str.substr(0, 2) == "no") {
+                    error += strprintf(", if you intended to specify a negated option, use %s=1 instead", str);
+                }
+                return false;
+            }
+        }
+        ++linenr;
+    }
+    return true;
+}
+
+bool IsConfSupported(KeyInfo& key, std::string& error) {
+    if (key.name == "conf") {
+        error = "conf cannot be set in the configuration file; use includeconf= if you want to include additional config files";
+        return false;
+    }
+    if (key.name == "reindex") {
+        // reindex can be set in a config file but it is strongly discouraged as this will cause the node to reindex on
+        // every restart. Allow the config but throw a warning
+        LogPrintf("Warning: reindex=1 is set in the configuration file, which will significantly slow down startup. Consider removing or commenting out this option for better performance, unless there is currently a condition which makes rebuilding the indexes necessary\n");
+        return true;
+    }
+    return true;
+}
+
+bool ArgsManager::ReadConfigStream(std::istream& stream, const std::string& filepath, std::string& error, bool ignore_invalid_keys)
+{
+    LOCK(cs_args);
+    std::vector<std::pair<std::string, std::string>> options;
+    if (!GetConfigOptions(stream, filepath, error, options, m_config_sections)) {
+        return false;
+    }
+    for (const std::pair<std::string, std::string>& option : options) {
+        KeyInfo key = InterpretKey(option.first);
+        std::optional<unsigned int> flags = GetArgFlags('-' + key.name);
+        if (!IsConfSupported(key, error)) return false;
+        if (flags) {
+            std::optional<common::SettingsValue> value = InterpretValue(key, &option.second, *flags, error);
+            if (!value) {
+                return false;
+            }
+            m_settings.ro_config[key.section][key.name].push_back(*value);
+        } else {
+            if (ignore_invalid_keys) {
+                LogPrintf("Ignoring unknown configuration value %s\n", option.first);
+            } else {
+                error = strprintf("Invalid configuration value %s", option.first);
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool ArgsManager::ReadConfigFiles(std::string& error, bool ignore_invalid_keys)
+{
+    {
+        LOCK(cs_args);
+        m_settings.ro_config.clear();
+        m_config_sections.clear();
+        m_config_path = AbsPathForConfigVal(*this, GetPathArg("-conf", BITCOIN_CONF_FILENAME), /*net_specific=*/false);
+    }
+
+    const auto conf_path{GetConfigFilePath()};
+    std::ifstream stream{conf_path};
+
+    // not ok to have a config file specified that cannot be opened
+    if (IsArgSet("-conf") && !stream.good()) {
+        error = strprintf("specified config file \"%s\" could not be opened.", fs::PathToString(conf_path));
+        return false;
+    }
+    // ok to not have a config file
+    if (stream.good()) {
+        if (!ReadConfigStream(stream, fs::PathToString(conf_path), error, ignore_invalid_keys)) {
+            return false;
+        }
+        // `-includeconf` cannot be included in the command line arguments except
+        // as `-noincludeconf` (which indicates that no included conf file should be used).
+        bool use_conf_file{true};
+        {
+            LOCK(cs_args);
+            if (auto* includes = common::FindKey(m_settings.command_line_options, "includeconf")) {
+                // ParseParameters() fails if a non-negated -includeconf is passed on the command-line
+                assert(common::SettingsSpan(*includes).last_negated());
+                use_conf_file = false;
+            }
+        }
+        if (use_conf_file) {
+            std::string chain_id = GetChainTypeString();
+            std::vector<std::string> conf_file_names;
+
+            auto add_includes = [&](const std::string& network, size_t skip = 0) {
+                size_t num_values = 0;
+                LOCK(cs_args);
+                if (auto* section = common::FindKey(m_settings.ro_config, network)) {
+                    if (auto* values = common::FindKey(*section, "includeconf")) {
+                        for (size_t i = std::max(skip, common::SettingsSpan(*values).negated()); i < values->size(); ++i) {
+                            conf_file_names.push_back((*values)[i].get_str());
+                        }
+                        num_values = values->size();
+                    }
+                }
+                return num_values;
+            };
+
+            // We haven't set m_network yet (that happens in SelectParams()), so manually check
+            // for network.includeconf args.
+            const size_t chain_includes = add_includes(chain_id);
+            const size_t default_includes = add_includes({});
+
+            for (const std::string& conf_file_name : conf_file_names) {
+                std::ifstream conf_file_stream{AbsPathForConfigVal(*this, fs::PathFromString(conf_file_name), /*net_specific=*/false)};
+                if (conf_file_stream.good()) {
+                    if (!ReadConfigStream(conf_file_stream, conf_file_name, error, ignore_invalid_keys)) {
+                        return false;
+                    }
+                    LogPrintf("Included configuration file %s\n", conf_file_name);
+                } else {
+                    error = "Failed to include configuration file " + conf_file_name;
+                    return false;
+                }
+            }
+
+            // Warn about recursive -includeconf
+            conf_file_names.clear();
+            add_includes(chain_id, /* skip= */ chain_includes);
+            add_includes({}, /* skip= */ default_includes);
+            std::string chain_id_final = GetChainTypeString();
+            if (chain_id_final != chain_id) {
+                // Also warn about recursive includeconf for the chain that was specified in one of the includeconfs
+                add_includes(chain_id_final);
+            }
+            for (const std::string& conf_file_name : conf_file_names) {
+                tfm::format(std::cerr, "warning: -includeconf cannot be used from included files; ignoring -includeconf=%s\n", conf_file_name);
+            }
+        }
+    }
+
+    // If datadir is changed in .conf file:
+    ClearPathCache();
+    if (!CheckDataDirOption(*this)) {
+        error = strprintf("specified data directory \"%s\" does not exist.", GetArg("-datadir", ""));
+        return false;
+    }
+    return true;
+}
+
+fs::path AbsPathForConfigVal(const ArgsManager& args, const fs::path& path, bool net_specific)
+{
+    if (path.is_absolute()) {
+        return path;
+    }
+    return fsbridge::AbsPathJoin(net_specific ? args.GetDataDirNet() : args.GetDataDirBase(), path);
+}
diff --git a/src/common/init.cpp b/src/common/init.cpp
index 7cebff8927d0..89439f9c609e 100644
--- a/src/common/init.cpp
+++ b/src/common/init.cpp
@@ -2,12 +2,13 @@
 // 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 <common/init.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <logging.h>
 #include <util/fs.h>
 #include <tinyformat.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <algorithm>
@@ -40,7 +41,7 @@ std::optional<ConfigError> InitConfig(ArgsManager& args, SettingsAbortFn setting
         }
 
         // Check for chain settings (Params() calls are only valid after this clause)
-        SelectParams(args.GetChainName());
+        SelectParams(args.GetChainType());
 
         // Create datadir if it does not exist.
         const auto base_path{args.GetDataDirBase()};
diff --git a/src/util/settings.cpp b/src/common/settings.cpp
similarity index 97%
rename from src/util/settings.cpp
rename to src/common/settings.cpp
index 663b99d645fc..7f073063afa7 100644
--- a/src/util/settings.cpp
+++ b/src/common/settings.cpp
@@ -2,8 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/fs.h>
-#include <util/settings.h>
+#include <common/settings.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
@@ -11,13 +10,17 @@
 
 #include <tinyformat.h>
 #include <univalue.h>
+#include <util/fs.h>
 
+#include <algorithm>
 #include <fstream>
+#include <iterator>
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
-namespace util {
+namespace common {
 namespace {
 
 enum class Source {
@@ -155,7 +158,7 @@ SettingsValue GetSetting(const Settings& settings,
     const std::string& name,
     bool ignore_default_section_config,
     bool ignore_nonpersistent,
-    bool get_chain_name)
+    bool get_chain_type)
 {
     SettingsValue result;
     bool done = false; // Done merging any more settings sources.
@@ -170,17 +173,17 @@ SettingsValue GetSetting(const Settings& settings,
         // assigned value instead of last. In general, later settings take
         // precedence over early settings, but for backwards compatibility in
         // the config file the precedence is reversed for all settings except
-        // chain name settings.
+        // chain type settings.
         const bool reverse_precedence =
             (source == Source::CONFIG_FILE_NETWORK_SECTION || source == Source::CONFIG_FILE_DEFAULT_SECTION) &&
-            !get_chain_name;
+            !get_chain_type;
 
         // Weird behavior preserved for backwards compatibility: Negated
         // -regtest and -testnet arguments which you would expect to override
         // values set in the configuration file are currently accepted but
         // silently ignored. It would be better to apply these just like other
         // negated values, or at least warn they are ignored.
-        const bool skip_negated_command_line = get_chain_name;
+        const bool skip_negated_command_line = get_chain_type;
 
         if (done) return;
 
@@ -280,4 +283,4 @@ size_t SettingsSpan::negated() const
     return 0;
 }
 
-} // namespace util
+} // namespace common
diff --git a/src/util/settings.h b/src/common/settings.h
similarity index 94%
rename from src/util/settings.h
rename to src/common/settings.h
index 27e87a475173..0e9d376e2386 100644
--- a/src/util/settings.h
+++ b/src/common/settings.h
@@ -2,18 +2,19 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_UTIL_SETTINGS_H
-#define BITCOIN_UTIL_SETTINGS_H
+#ifndef BITCOIN_COMMON_SETTINGS_H
+#define BITCOIN_COMMON_SETTINGS_H
 
 #include <util/fs.h>
 
+#include <cstddef>
 #include <map>
 #include <string>
 #include <vector>
 
 class UniValue;
 
-namespace util {
+namespace common {
 
 //! Settings value type (string/integer/boolean/null variant).
 //!
@@ -60,14 +61,14 @@ bool WriteSettings(const fs::path& path,
 //!                               command line). Only return settings in the
 //!                               read-only config and read-write settings
 //!                               files.
-//! @param get_chain_name - enable special backwards compatible behavior
-//!                         for GetChainName
+//! @param get_chain_type - enable special backwards compatible behavior
+//!                         for GetChainType
 SettingsValue GetSetting(const Settings& settings,
     const std::string& section,
     const std::string& name,
     bool ignore_default_section_config,
     bool ignore_nonpersistent,
-    bool get_chain_name);
+    bool get_chain_type);
 
 //! Get combined setting value similar to GetSetting(), except if setting was
 //! specified multiple times, return a list of all the values specified.
@@ -109,6 +110,6 @@ auto FindKey(Map&& map, Key&& key) -> decltype(&map.at(key))
     return it == map.end() ? nullptr : &it->second;
 }
 
-} // namespace util
+} // namespace common
 
-#endif // BITCOIN_UTIL_SETTINGS_H
+#endif // BITCOIN_COMMON_SETTINGS_H
diff --git a/src/common/system.cpp b/src/common/system.cpp
new file mode 100644
index 000000000000..d9249c264495
--- /dev/null
+++ b/src/common/system.cpp
@@ -0,0 +1,163 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2022 The Bitcoin 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.
+
+#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
+#include <sys/stat.h>
+#else
+#include <codecvt>
+#endif
+
+#ifdef HAVE_MALLOPT_ARENA_MAX
+#include <malloc.h>
+#endif
+
+#include <cstdlib>
+#include <future>
+#include <locale>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <thread>
+
+// Application startup time (used for uptime calculation)
+const int64_t nStartupTime = GetTime();
+
+//Dash only features
+const std::string gCoinJoinName = "CoinJoin";
+
+/**
+    nWalletBackups:
+        1..10   - number of automatic backups to keep
+        0       - disabled by command-line
+        -1      - disabled because of some error during run-time
+        -2      - disabled because wallet was locked and we were not able to replenish keypool
+*/
+int nWalletBackups = 10;
+
+#ifndef WIN32
+std::string ShellEscape(const std::string& arg)
+{
+    std::string escaped = arg;
+    ReplaceAll(escaped, "'", "'\"'\"'");
+    return "'" + escaped + "'";
+}
+#endif
+
+#if HAVE_SYSTEM
+void runCommand(const std::string& strCommand)
+{
+    if (strCommand.empty()) return;
+#ifndef WIN32
+    int nErr = ::system(strCommand.c_str());
+#else
+    int nErr = ::_wsystem(std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>,wchar_t>().from_bytes(strCommand).c_str());
+#endif
+    if (nErr)
+        LogPrintf("runCommand error: system(%s) returned %d\n", strCommand, nErr);
+}
+#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
+    // glibc-specific: On 32-bit systems set the number of arenas to 1.
+    // By default, since glibc 2.10, the C library will create up to two heap
+    // arenas per core. This is known to cause excessive virtual address space
+    // usage in our usage. Work around it by setting the maximum number of
+    // arenas to 1.
+    if (sizeof(void*) == 4) {
+        mallopt(M_ARENA_MAX, 1);
+    }
+#endif
+    // On most POSIX systems (e.g. Linux, but not BSD) the environment's locale
+    // may be invalid, in which case the "C.UTF-8" locale is used as fallback.
+#if !defined(WIN32) && !defined(MAC_OSX) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
+    try {
+        std::locale(""); // Raises a runtime error if current locale is invalid
+    } catch (const std::runtime_error&) {
+        setenv("LC_ALL", "C.UTF-8", 1);
+    }
+#elif defined(WIN32)
+    // Set the default input/output charset is utf-8
+    SetConsoleCP(CP_UTF8);
+    SetConsoleOutputCP(CP_UTF8);
+#endif
+
+#ifndef WIN32
+    constexpr mode_t private_umask = 0077;
+    umask(private_umask);
+#endif
+}
+
+bool SetupNetworking()
+{
+#ifdef WIN32
+    // Initialize Windows Sockets
+    WSADATA wsadata;
+    int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
+    if (ret != NO_ERROR || LOBYTE(wsadata.wVersion ) != 2 || HIBYTE(wsadata.wVersion) != 2)
+        return false;
+#endif
+    return true;
+}
+
+int GetNumCores()
+{
+    return std::thread::hardware_concurrency();
+}
+
+// Obtain the application startup time (used for uptime calculation)
+int64_t GetStartupTime()
+{
+    return nStartupTime;
+}
diff --git a/src/common/system.h b/src/common/system.h
new file mode 100644
index 000000000000..8e54b9e526d1
--- /dev/null
+++ b/src/common/system.h
@@ -0,0 +1,50 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2022 The Bitcoin 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_COMMON_SYSTEM_H
+#define BITCOIN_COMMON_SYSTEM_H
+
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+
+#include <compat/assumptions.h>
+#include <compat/compat.h>
+#include <consensus/amount.h>
+
+#include <set>
+#include <stdint.h>
+#include <string>
+
+//Dash only features
+
+extern int nWalletBackups;
+extern const std::string gCoinJoinName;
+
+// Application startup time (used for uptime calculation)
+int64_t GetStartupTime();
+
+void SetupEnvironment();
+[[nodiscard]] bool SetupNetworking();
+#ifndef WIN32
+std::string ShellEscape(const std::string& arg);
+#endif
+#if HAVE_SYSTEM
+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.
+ */
+int GetNumCores();
+
+#endif // BITCOIN_COMMON_SYSTEM_H
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 8303cad671c3..d3ae39fb367c 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -4,6 +4,7 @@
 
 #include <core_io.h>
 
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <key_io.h>
@@ -17,7 +18,6 @@
 #include <univalue.h>
 #include <util/check.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 
 #include <index/spentindex_types.h>
 
diff --git a/src/dbwrapper.cpp b/src/dbwrapper.cpp
index 41e8829ab016..ecc406699b32 100644
--- a/src/dbwrapper.cpp
+++ b/src/dbwrapper.cpp
@@ -5,6 +5,7 @@
 #include <dbwrapper.h>
 
 #include <clientversion.h>
+#include <common/system.h>
 #include <logging.h>
 #include <random.h>
 #include <serialize.h>
@@ -13,7 +14,6 @@
 #include <util/fs.h>
 #include <util/fs_helpers.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 
 #include <algorithm>
 #include <cassert>
diff --git a/src/dummywallet.cpp b/src/dummywallet.cpp
index 6f9e18d8b27e..d02cf96adbe0 100644
--- a/src/dummywallet.cpp
+++ b/src/dummywallet.cpp
@@ -2,8 +2,9 @@
 // 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 <common/system.h>
 #include <logging.h>
-#include <util/system.h>
 #include <walletinitinterface.h>
 
 class ArgsManager;
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index a74c3f1da954..be084d47cdd6 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -20,7 +20,6 @@
 #include <node/blockstorage.h>
 #include <util/time.h>
 
-using node::ReadBlockFromDisk;
 
 bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, bool is_v24_active, TxValidationState& state)
 {
@@ -195,7 +194,7 @@ std::string CCbTx::ToString() const
         creditPoolBalance / COIN, creditPoolBalance % COIN, merkleRootAssetUnlocks.ToString());
 }
 
-std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex)
+std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const node::BlockManager& blockman, const CBlockIndex* pindex)
 {
     if (pindex == nullptr) {
         return std::nullopt;
@@ -207,7 +206,7 @@ std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(co
     }
 
     CBlock block;
-    if (!ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+    if (!blockman.ReadBlockFromDisk(block, *pindex)) {
         return std::nullopt;
     }
 
diff --git a/src/evo/cbtx.h b/src/evo/cbtx.h
index 45ddee56b310..09201841ef8c 100644
--- a/src/evo/cbtx.h
+++ b/src/evo/cbtx.h
@@ -21,6 +21,10 @@ class CDeterministicMNList;
 class TxValidationState;
 struct RPCResult;
 
+namespace node {
+class BlockManager;
+} // namespace node
+
 namespace llmq {
 class CQuorumBlockProcessor;
 }// namespace llmq
@@ -83,7 +87,7 @@ bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPre
                                BlockValidationState& state);
 uint256 CalcCbTxMerkleRootAssetUnlocks(const CBlock& block);
 
-std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex);
+std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const node::BlockManager& blockman, const CBlockIndex* pindex);
 std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlock& block, int32_t height);
 
 #endif // BITCOIN_EVO_CBTX_H
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index cafe65b023f4..3f0aeb52e665 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -26,7 +26,6 @@
 #include <stack>
 #include <stdexcept>
 
-using node::ReadBlockFromDisk;
 
 static const std::string DB_CREDITPOOL_SNAPSHOT = "cpm_S";
 
@@ -62,6 +61,7 @@ struct CreditPoolDataPerBlock {
 
 // it throws exception if anything went wrong
 static std::optional<CreditPoolDataPerBlock> GetCreditDataFromBlock(const gsl::not_null<const CBlockIndex*> block_index,
+                                                                    const node::BlockManager& blockman,
                                                                     const Consensus::Params& consensusParams)
 {
     // There's no CbTx before DIP0003 activation
@@ -79,7 +79,7 @@ static std::optional<CreditPoolDataPerBlock> GetCreditDataFromBlock(const gsl::n
     }
 
     CBlock block;
-    if (!ReadBlockFromDisk(block, block_index, consensusParams)) {
+    if (!blockman.ReadBlockFromDisk(block, *block_index)) {
         throw std::runtime_error("failed-getcbforblock-read");
     }
 
@@ -172,7 +172,7 @@ void CCreditPoolManager::AddToCache(const uint256& block_hash, int height, const
 
 CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CBlockIndex*> block_index, CCreditPool prev)
 {
-    std::optional<CreditPoolDataPerBlock> opt_block_data = GetCreditDataFromBlock(block_index, m_chainman.GetConsensus());
+    std::optional<CreditPoolDataPerBlock> opt_block_data = GetCreditDataFromBlock(block_index, m_chainman.m_blockman, m_chainman.GetConsensus());
     if (!opt_block_data) {
         // If reading of previous block is not successfully, but
         // prev contains credit pool related data, something strange happened
@@ -204,7 +204,7 @@ CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CB
     CAmount distantBalance{0};
     if (distant_block_index) {
         if (std::optional<CreditPoolDataPerBlock> distant_block{
-                GetCreditDataFromBlock(distant_block_index, m_chainman.GetConsensus())};
+                GetCreditDataFromBlock(distant_block_index, m_chainman.m_blockman, m_chainman.GetConsensus())};
             distant_block) {
             distantUnlocked = distant_block->unlocked;
             distantBalance = distant_block->credit_pool;
@@ -247,9 +247,9 @@ CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CB
 }
 
 CAmount CCreditPoolManager::GetBalanceAt(const gsl::not_null<const CBlockIndex*> block_index,
-                                         const Consensus::Params& consensusParams)
+                                         const node::BlockManager& blockman, const Consensus::Params& consensusParams)
 {
-    const std::optional<CreditPoolDataPerBlock> block_data{GetCreditDataFromBlock(block_index, consensusParams)};
+    const std::optional<CreditPoolDataPerBlock> block_data{GetCreditDataFromBlock(block_index, blockman, consensusParams)};
     return block_data ? block_data->credit_pool : CAmount{0};
 }
 
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index 060a570e17ca..f73baa1981dd 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -27,6 +27,9 @@ class BlockValidationState;
 class CBlock;
 class CBlockIndex;
 class ChainstateManager;
+namespace node {
+class BlockManager;
+} // namespace node
 class CEvoDB;
 class TxValidationState;
 namespace Consensus {
@@ -159,7 +162,8 @@ class CCreditPoolManager
     /** The credit pool balance after `block_index` as its CbTx records it, 0 when the block has
      *  no credit pool; the read the v24 rule makes for its window start. Throws if the block
      *  cannot be read. */
-    static CAmount GetBalanceAt(gsl::not_null<const CBlockIndex*> block_index, const Consensus::Params& consensusParams);
+    static CAmount GetBalanceAt(gsl::not_null<const CBlockIndex*> block_index, const node::BlockManager& blockman,
+                                const Consensus::Params& consensusParams);
 
     CCreditPoolManager() = delete;
     CCreditPoolManager(const CCreditPoolManager&) = delete;
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 2d07f290ae6b..70288671d0a6 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -1182,7 +1182,7 @@ bool CDeterministicMNManager::MigrateLegacyDiffs(const CBlockIndex* const tip_in
 }
 
 CDeterministicMNManager::RecalcDiffsResult CDeterministicMNManager::RecalculateAndRepairDiffs(
-    const CBlockIndex* start_index, const CBlockIndex* stop_index, BuildListFromBlockFunc build_list_func, bool repair)
+    const node::BlockManager& blockman, const CBlockIndex* start_index, const CBlockIndex* stop_index, BuildListFromBlockFunc build_list_func, bool repair)
 {
     RecalcDiffsResult result;
     result.start_height = start_index->nHeight;
@@ -1273,7 +1273,7 @@ CDeterministicMNManager::RecalcDiffsResult CDeterministicMNManager::RecalculateA
 
         // If repair mode is enabled and verification failed, recalculate diffs from blockchain
         if (repair && !is_snapshot_pair_valid) {
-            auto temp_diffs = RepairSnapshotPair(from_index, to_index, from_snapshot, to_snapshot, build_list_func, result);
+            auto temp_diffs = RepairSnapshotPair(blockman, from_index, to_index, from_snapshot, to_snapshot, build_list_func, result);
             if (temp_diffs.empty()) {
                 // RepairSnapshotPair failed - this is a critical error, cannot continue
                 return result;
@@ -1402,7 +1402,7 @@ bool CDeterministicMNManager::VerifySnapshotPair(
 }
 
 std::vector<std::pair<uint256, CDeterministicMNListDiff>> CDeterministicMNManager::RepairSnapshotPair(
-    const CBlockIndex* from_index, const CBlockIndex* to_index, const CDeterministicMNList& from_snapshot,
+    const node::BlockManager& blockman, const CBlockIndex* from_index, const CBlockIndex* to_index, const CDeterministicMNList& from_snapshot,
     const CDeterministicMNList& to_snapshot, BuildListFromBlockFunc build_list_func, RecalcDiffsResult& result)
 {
     CDeterministicMNList current_list = from_snapshot;
@@ -1419,7 +1419,7 @@ std::vector<std::pair<uint256, CDeterministicMNListDiff>> CDeterministicMNManage
 
             // Read the actual block from disk
             CBlock block;
-            if (!node::ReadBlockFromDisk(block, pIndex, Params().GetConsensus())) {
+            if (!blockman.ReadBlockFromDisk(block, *pIndex)) {
                 result.repair_errors.push_back(strprintf("CRITICAL: Failed to read block at height %d. "
                     "Cannot repair - full reindex required.", nHeight));
                 return {}; // Critical error - cannot continue repair
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 082cce0a7867..ce4df7367fab 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -33,6 +33,9 @@ class CBlock;
 class CBlockIndex;
 class CCoinsViewCache;
 class ChainstateManager;
+namespace node {
+class BlockManager;
+} // namespace node
 class CEvoDB;
 class CSimplifiedMNList;
 class CSimplifiedMNListEntry;
@@ -830,7 +833,8 @@ class CDeterministicMNManager
         BlockValidationState& state,
         CDeterministicMNList& mnListRet)>;
 
-    [[nodiscard]] RecalcDiffsResult RecalculateAndRepairDiffs(const CBlockIndex* start_index,
+    [[nodiscard]] RecalcDiffsResult RecalculateAndRepairDiffs(const node::BlockManager& blockman,
+                                                              const CBlockIndex* start_index,
                                                               const CBlockIndex* stop_index,
                                                               BuildListFromBlockFunc build_list_func, bool repair)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
@@ -853,7 +857,7 @@ class CDeterministicMNManager
                             const CDeterministicMNList& from_snapshot, const CDeterministicMNList& to_snapshot,
                             RecalcDiffsResult& result);
     static std::vector<std::pair<uint256, CDeterministicMNListDiff>> RepairSnapshotPair(
-        const CBlockIndex* from_index, const CBlockIndex* to_index, const CDeterministicMNList& from_snapshot,
+        const node::BlockManager& blockman, const CBlockIndex* from_index, const CBlockIndex* to_index, const CDeterministicMNList& from_snapshot,
         const CDeterministicMNList& to_snapshot, BuildListFromBlockFunc build_list_func, RecalcDiffsResult& result);
     void WriteRepairedDiffs(const std::vector<std::pair<uint256, CDeterministicMNListDiff>>& recalculated_diffs)
         EXCLUSIVE_LOCKS_REQUIRED(!cs);
diff --git a/src/evo/mnauth.cpp b/src/evo/mnauth.cpp
index 99ca508aa069..dbfd99dabb98 100644
--- a/src/evo/mnauth.cpp
+++ b/src/evo/mnauth.cpp
@@ -12,6 +12,8 @@
 #include <masternode/sync.h>
 
 #include <chainparams.h>
+#include <common/args.h>
+#include <logging.h>
 #include <net.h>
 #include <netmessagemaker.h>
 #include <util/time.h>
@@ -34,7 +36,7 @@ void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CActiveMasternode
     //   node1 -> Eve -> node2
     // This is ok as we only use MNAUTH as a DoS protection and not for sensitive stuff
     int nOurNodeVersion{PROTOCOL_VERSION};
-    if (Params().NetworkIDString() != CBaseChainParams::MAIN && gArgs.IsArgSet("-pushversion")) {
+    if (Params().GetChainType() != ChainType::MAIN && gArgs.IsArgSet("-pushversion")) {
         nOurNodeVersion = gArgs.GetIntArg("-pushversion", PROTOCOL_VERSION);
     }
     const uint256 signHash{::SerializeHash(std::make_tuple(mn_activeman.GetPubKey(), receivedMNAuthChallenge, peer.IsInboundConn(), nOurNodeVersion))};
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
index 806add0fd78f..1a2555cd3628 100644
--- a/src/evo/mnhftx.cpp
+++ b/src/evo/mnhftx.cpp
@@ -23,7 +23,6 @@
 #include <string>
 #include <vector>
 
-using node::ReadBlockFromDisk;
 
 static const std::string MNEHF_REQUESTID_PREFIX = "mnhf";
 static const std::string DB_SIGNALS = "mnhf_s";
@@ -44,8 +43,9 @@ CMutableTransaction MNHFTxPayload::PrepareTx() const
     return tx;
 }
 
-CMNHFManager::CMNHFManager(CEvoDB& evoDb, const Consensus::Params& consensus_params) :
+CMNHFManager::CMNHFManager(CEvoDB& evoDb, const node::BlockManager& blockman, const Consensus::Params& consensus_params) :
     m_evoDb(evoDb),
+    m_blockman{blockman},
     m_consensus_params{consensus_params}
 {
     assert(globalInstance == nullptr);
@@ -300,7 +300,7 @@ CMNHFManager::Signals CMNHFManager::GetForBlock(const CBlockIndex* pindex)
             LogPrintf("re-index EHF signals at block %d\n", pindex_top->nHeight);
         }
         CBlock block;
-        if (!ReadBlockFromDisk(block, pindex_top, m_consensus_params)) {
+        if (!m_blockman.ReadBlockFromDisk(block, *pindex_top)) {
             throw std::runtime_error("failed-getehfforblock-read");
         }
         BlockValidationState state;
diff --git a/src/evo/mnhftx.h b/src/evo/mnhftx.h
index 8a0bc91455a7..36d4f47bee92 100644
--- a/src/evo/mnhftx.h
+++ b/src/evo/mnhftx.h
@@ -99,6 +99,7 @@ class CMNHFManager : public AbstractEHFManager
     // TODO: store in database active EHF signals not for each block;
     // but quite opposite: keep only hash of block where signal is added.
     // TODO: implement migration to a new format
+    const node::BlockManager& m_blockman;
     const Consensus::Params& m_consensus_params;
 
     static constexpr size_t MNHFCacheSize = 1000;
@@ -110,7 +111,7 @@ class CMNHFManager : public AbstractEHFManager
     CMNHFManager() = delete;
     CMNHFManager(const CMNHFManager&) = delete;
     CMNHFManager& operator=(const CMNHFManager&) = delete;
-    explicit CMNHFManager(CEvoDB& evoDb, const Consensus::Params& consensus_params);
+    explicit CMNHFManager(CEvoDB& evoDb, const node::BlockManager& blockman, const Consensus::Params& consensus_params);
     ~CMNHFManager() override;
 
     /**
diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index 029c60e8a2a7..aa27f5863ff7 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -2,15 +2,16 @@
 // 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>
+#include <common/system.h>
 #include <evo/types.h>
 #include <netbase.h>
 #include <span.h>
 #include <util/check.h>
 #include <util/string.h>
-#include <util/system.h>
 
 #include <univalue.h>
 
@@ -87,7 +88,7 @@ NetInfoStatus ValidateMainnetPrimaryPort(NetInfoPurpose purpose, const NetInfoEn
 }
 } // anonymous namespace
 
-bool IsNodeOnMainnet() { return Params().NetworkIDString() == CBaseChainParams::MAIN; }
+bool IsNodeOnMainnet() { return Params().GetChainType() == ChainType::MAIN; }
 
 bool IsServiceDeprecatedRPCEnabled()
 {
@@ -97,7 +98,7 @@ bool IsServiceDeprecatedRPCEnabled()
 
 const CChainParams& MainParams()
 {
-    std::call_once(g_main_params_flag, [&]() { g_main_params = CreateChainParams(::gArgs, CBaseChainParams::MAIN); });
+    std::call_once(g_main_params_flag, [&]() { g_main_params = CreateChainParams(::gArgs, ChainType::MAIN); });
     return *Assert(g_main_params);
 }
 
diff --git a/src/evo/smldiff.cpp b/src/evo/smldiff.cpp
index 255e5a688251..6413b3bf58c1 100644
--- a/src/evo/smldiff.cpp
+++ b/src/evo/smldiff.cpp
@@ -19,10 +19,9 @@
 #include <univalue.h>
 #include <validation.h>
 
-using node::ReadBlockFromDisk;
 
 // Forward declaration
-std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex);
+std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const node::BlockManager& blockman, const CBlockIndex* pindex);
 
 CSimplifiedMNListDiff::CSimplifiedMNListDiff() = default;
 
@@ -66,7 +65,7 @@ bool CSimplifiedMNListDiff::BuildQuorumsDiff(const CBlockIndex* baseBlockIndex,
     return true;
 }
 
-bool CSimplifiedMNListDiff::BuildQuorumChainlockInfo(const llmq::CQuorumManager& qman, const CBlockIndex* blockIndex)
+bool CSimplifiedMNListDiff::BuildQuorumChainlockInfo(const llmq::CQuorumManager& qman, const node::BlockManager& blockman, const CBlockIndex* blockIndex)
 {
     // Group quorums (indexes corresponding to entries of newQuorums) per CBlockIndex containing the expected CL
     // signature in CbTx. We want to avoid to load CbTx now, as more than one quorum will target the same block: hence
@@ -95,7 +94,7 @@ bool CSimplifiedMNListDiff::BuildQuorumChainlockInfo(const llmq::CQuorumManager&
     for (auto it = workBaseBlockIndexMap.begin(); it != workBaseBlockIndexMap.end();) {
         // Process each key (CBlockIndex containing the expected CL signature in CbTx) of the std::multimap once
         const CBlockIndex* pWorkBaseBlockIndex = it->first;
-        const auto cbcl = GetNonNullCoinbaseChainlock(pWorkBaseBlockIndex);
+        const auto cbcl = GetNonNullCoinbaseChainlock(blockman, pWorkBaseBlockIndex);
         CBLSSignature sig;
         if (cbcl.has_value()) {
             sig = cbcl.value().first;
@@ -219,7 +218,7 @@ bool BuildSimplifiedMNListDiff(CDeterministicMNManager& dmnman, const Chainstate
     }
 
     if (DeploymentActiveAfter(blockIndex, chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) {
-        if (!mnListDiffRet.BuildQuorumChainlockInfo(qman, blockIndex)) {
+        if (!mnListDiffRet.BuildQuorumChainlockInfo(qman, chainman.m_blockman, blockIndex)) {
             errorRet = strprintf("failed to build quorum chainlock info");
             return false;
         }
@@ -227,7 +226,7 @@ bool BuildSimplifiedMNListDiff(CDeterministicMNManager& dmnman, const Chainstate
 
     // TODO store coinbase TX in CBlockIndex
     CBlock block;
-    if (!ReadBlockFromDisk(block, blockIndex, chainman.GetConsensus())) {
+    if (!chainman.m_blockman.ReadBlockFromDisk(block, *blockIndex)) {
         errorRet = strprintf("failed to read block %s from disk", blockHash.ToString());
         return false;
     }
diff --git a/src/evo/smldiff.h b/src/evo/smldiff.h
index 7c3d6b67fd2b..8c551018aa9e 100644
--- a/src/evo/smldiff.h
+++ b/src/evo/smldiff.h
@@ -22,6 +22,9 @@ class CDeterministicMNList;
 class CDeterministicMNManager;
 class UniValue;
 class ChainstateManager;
+namespace node {
+class BlockManager;
+} // namespace node
 struct RPCResult;
 
 namespace llmq {
@@ -83,7 +86,7 @@ class CSimplifiedMNListDiff
 
     bool BuildQuorumsDiff(const CBlockIndex* baseBlockIndex, const CBlockIndex* blockIndex,
                           const llmq::CQuorumBlockProcessor& quorum_block_processor);
-    bool BuildQuorumChainlockInfo(const llmq::CQuorumManager& qman, const CBlockIndex* blockIndex);
+    bool BuildQuorumChainlockInfo(const llmq::CQuorumManager& qman, const node::BlockManager& blockman, const CBlockIndex* blockIndex);
 
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson(bool extended = false) const;
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 4a3dc64626c9..eb2f68cb730a 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -23,12 +23,12 @@
 
 #include <chainparams.h>
 #include <coins.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <hash.h>
 #include <primitives/block.h>
-#include <util/system.h>
 #include <util/time.h>
 
 CSpecialTxProcessor::CSpecialTxProcessor(CEvoDB& evodb, CDeterministicMNManager& dmnman,
@@ -37,7 +37,7 @@ CSpecialTxProcessor::CSpecialTxProcessor(CEvoDB& evodb, CDeterministicMNManager&
                                          const Consensus::Params& consensus_params,
                                          const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman) :
     m_cpoolman{std::make_unique<CCreditPoolManager>(evodb, chainman)},
-    m_mnhfman{std::make_unique<CMNHFManager>(evodb, consensus_params)},
+    m_mnhfman{std::make_unique<CMNHFManager>(evodb, blockman, consensus_params)},
     m_dmnman{dmnman},
     m_qblockman{qblockman},
     m_qsnapman{qsnapman},
@@ -158,7 +158,7 @@ static bool ApplyProUpServTx(CDeterministicMNState& state_mn, const CProUpServTx
 }
 
 bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const Consensus::Params& consensus_params,
-                            const CChain& chain, const llmq::CQuorumManager& qman,
+                            const node::BlockManager& blockman, const CChain& chain, const llmq::CQuorumManager& qman,
                             const chainlock::Chainlocks& chainlocks, BlockValidationState& state)
 {
     if (cbTx.nVersion < CCbTx::Version::CLSIG_AND_BALANCE) {
@@ -192,7 +192,7 @@ bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const
         prev_verified_here = cached->verified_here;
     }
     if (!prevBlockCoinbaseChainlock.has_value()) {
-        prevBlockCoinbaseChainlock = GetNonNullCoinbaseChainlock(pindex->pprev);
+        prevBlockCoinbaseChainlock = GetNonNullCoinbaseChainlock(blockman, pindex->pprev);
     }
     // If std::optional prevBlockCoinbaseChainlock is empty, then up to the previous block, coinbase Chainlock is null.
     if (prevBlockCoinbaseChainlock.has_value()) {
@@ -1069,7 +1069,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
             LogPrint(BCLog::BENCHMARK, "      - CalcCbTxMerkleRootQuorums: %.2fms [%.2fs]\n",
                      Ticks<MillisecondsDouble>(nTime6_2 - nTime6_1), Ticks<SecondsDouble>(nTimeMerkleQuorums));
 
-            if (!CheckCbTxBestChainlock(*opt_cbTx, pindex, m_consensus_params, chain, m_qman, m_chainlocks, state)) {
+            if (!CheckCbTxBestChainlock(*opt_cbTx, pindex, m_consensus_params, m_blockman, chain, m_qman, m_chainlocks, state)) {
                 // pass the state returned by the function above
                 return false;
             }
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index 10ec910e30e3..f9caf98ef4c7 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -181,7 +181,7 @@ std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<c
 
 /** Validates the bestCLSignature / bestCLHeightDiff fields embedded in a CbTx payload. */
 bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const Consensus::Params& consensus_params,
-                            const CChain& chain, const llmq::CQuorumManager& qman,
+                            const node::BlockManager& blockman, const CChain& chain, const llmq::CQuorumManager& qman,
                             const chainlock::Chainlocks& chainlocks, BlockValidationState& state);
 
 bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
diff --git a/src/external_signer.h b/src/external_signer.h
index 4c2d0e2bdfb9..52c8a9d5ded2 100644
--- a/src/external_signer.h
+++ b/src/external_signer.h
@@ -5,8 +5,8 @@
 #ifndef BITCOIN_EXTERNAL_SIGNER_H
 #define BITCOIN_EXTERNAL_SIGNER_H
 
+#include <common/system.h>
 #include <univalue.h>
-#include <util/system.h>
 
 #include <string>
 #include <vector>
diff --git a/src/flat-database.h b/src/flat-database.h
index 2c484e3c37e7..d4b32ba300b3 100644
--- a/src/flat-database.h
+++ b/src/flat-database.h
@@ -7,10 +7,12 @@
 
 #include <clientversion.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <hash.h>
+#include <logging.h>
 #include <streams.h>
 #include <util/fs.h>
-#include <util/system.h>
 
 /**
 *   Generic Dumping and Loading
diff --git a/src/flatfile.cpp b/src/flatfile.cpp
index bee9e6d9b51c..252da948fe08 100644
--- a/src/flatfile.cpp
+++ b/src/flatfile.cpp
@@ -5,11 +5,11 @@
 
 #include <stdexcept>
 
+#include <common/system.h>
 #include <flatfile.h>
 #include <logging.h>
 #include <tinyformat.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 
 FlatFileSeq::FlatFileSeq(fs::path dir, const char* prefix, size_t chunk_size) :
     m_dir(std::move(dir)),
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 7fb083af9c2d..cb75a854a86b 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -16,6 +16,7 @@
 #include <chainparams.h>
 #include <common/bloom.h>
 #include <deploymentstatus.h>
+#include <logging.h>
 #include <net.h>
 #include <node/interface_ui.h>
 #include <protocol.h>
diff --git a/src/governance/superblock.cpp b/src/governance/superblock.cpp
index e4bfeb171e12..d14c6a2cff11 100644
--- a/src/governance/superblock.cpp
+++ b/src/governance/superblock.cpp
@@ -245,7 +245,7 @@ bool CSuperblock::IsExpired(int heightToTest) const
         return true;
     }
 
-    if (Params().NetworkIDString() != CBaseChainParams::MAIN) {
+    if (Params().GetChainType() != ChainType::MAIN) {
         // NOTE: this can happen on testnet/devnets due to reorgs, should never happen on mainnet
         if (heightToTest + Params().GetConsensus().nSuperblockCycle * 2 < nBlockHeight) {
             LogPrint(BCLog::GOBJECT, "CSuperblock::IsExpired -- Trigger is too far into the future\n");
diff --git a/src/governance/vote.cpp b/src/governance/vote.cpp
index c0081d7bb053..2b5265c62d69 100644
--- a/src/governance/vote.cpp
+++ b/src/governance/vote.cpp
@@ -173,7 +173,7 @@ bool CGovernanceVote::CheckSignature(const CKeyID& keyID) const
     bool valid{false};
 
     // Harden Spork6 so that it is active on testnet and no other networks
-    if (Params().NetworkIDString() == CBaseChainParams::TESTNET) {
+    if (Params().GetChainType() == ChainType::TESTNET) {
         valid = CHashSigner::VerifyHash(sigHash, keyID, vchSig, strError);
         if (!valid) {
             LogPrint(BCLog::GOBJECT, "CGovernanceVote::IsValid -- VerifyHash() failed, error: %s\n", strError);
diff --git a/src/httprpc.cpp b/src/httprpc.cpp
index 295656ff73a7..ffd73f68d72f 100644
--- a/src/httprpc.cpp
+++ b/src/httprpc.cpp
@@ -4,14 +4,15 @@
 
 #include <httprpc.h>
 
+#include <common/args.h>
 #include <crypto/hmac_sha256.h>
 #include <httpserver.h>
+#include <logging.h>
 #include <netaddress.h>
 #include <rpc/protocol.h>
 #include <rpc/server.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <walletinitinterface.h>
 
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
index b3d6c8d0d405..5d037e49f7f8 100644
--- a/src/httpserver.cpp
+++ b/src/httpserver.cpp
@@ -9,6 +9,9 @@
 #include <httpserver.h>
 
 #include <chainparamsbase.h>
+#include <common/args.h>
+#include <common/system.h>
+#include <logging.h>
 #include <netbase.h>
 #include <node/interface_ui.h>
 #include <rpc/protocol.h> // For HTTP status codes
@@ -16,7 +19,6 @@
 #include <sync.h>
 #include <util/check.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
 
diff --git a/src/i2p.cpp b/src/i2p.cpp
index 8f963f538cc8..d6953044712b 100644
--- a/src/i2p.cpp
+++ b/src/i2p.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <common/args.h>
 #include <compat/compat.h>
 #include <compat/endian.h>
 #include <crypto/sha256.h>
@@ -18,7 +19,6 @@
 #include <util/sock.h>
 #include <util/spanparsing.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/threadinterrupt.h>
 
 #include <chrono>
@@ -362,7 +362,7 @@ void Session::GenerateAndSavePrivateKey(const Sock& sock)
 {
     DestGenerate(sock);
 
-    // umask is set to 0077 in util/system.cpp, which is ok.
+    // umask is set to 0077 in common/system.cpp, which is ok.
     if (!WriteBinaryFile(m_private_key_file,
                          std::string(m_private_key.begin(), m_private_key.end()))) {
         throw std::runtime_error(
diff --git a/src/index/addressindex.cpp b/src/index/addressindex.cpp
index 8ce3783ea36f..82c4bead000a 100644
--- a/src/index/addressindex.cpp
+++ b/src/index/addressindex.cpp
@@ -2,17 +2,18 @@
 // 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 <index/addressindex.h>
 
 #include <chainparams.h>
 #include <clientversion.h>
+#include <common/system.h>
 #include <hash.h>
 #include <index/addressindex_util.h>
 #include <logging.h>
 #include <node/blockstorage.h>
 #include <tinyformat.h>
 #include <undo.h>
-#include <util/system.h>
 #include <validation.h>
 
 constexpr uint8_t DB_ADDRESSINDEX{'a'};
@@ -178,7 +179,7 @@ bool AddressIndex::CustomAppend(const interfaces::BlockInfo& block)
 
     // Read undo data for this block to get information about spent outputs
     CBlockUndo blockundo;
-    if (!node::UndoReadFromDisk(blockundo, pindex)) {
+    if (!m_chainstate->m_blockman.UndoReadFromDisk(blockundo, *pindex)) {
         LogError("%s: Failed to read undo data for block %s at height %d\n", __func__,
                  block.hash.ToString(), block.height);
         return false;
@@ -283,14 +284,14 @@ bool AddressIndex::CustomRewind(const interfaces::BlockKey& current_tip, const i
     // We need to undo all operations from current_tip back to (but not including) new_tip
     return RewindBlockByBlock(current_tip_index, new_tip_index, [&](const CBlockIndex* pindex, CDBBatch& batch) {
         CBlock block;
-        if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+        if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *pindex)) {
             LogError("%s: Failed to read block %s from disk during rewind\n", "CustomRewind",
                      pindex->GetBlockHash().ToString());
             return false;
         }
 
         CBlockUndo blockundo;
-        if (pindex->nHeight > 0 && !node::UndoReadFromDisk(blockundo, pindex)) {
+        if (pindex->nHeight > 0 && !m_chainstate->m_blockman.UndoReadFromDisk(blockundo, *pindex)) {
             LogError("%s: Failed to read undo data for block %s during rewind\n", "CustomRewind",
                      pindex->GetBlockHash().ToString());
             return false;
diff --git a/src/index/base.cpp b/src/index/base.cpp
index bbdc430b0218..7c9b9056b2ce 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -3,6 +3,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <index/base.h>
 #include <interfaces/chain.h>
 #include <kernel/chain.h>
@@ -13,7 +15,6 @@
 #include <node/interface_ui.h>
 #include <shutdown.h>
 #include <tinyformat.h>
-#include <util/system.h>
 #include <util/thread.h>
 #include <util/translation.h>
 #include <validation.h>
@@ -23,7 +24,6 @@
 #include <utility>
 
 using node::PruneLockInfo;
-using node::ReadBlockFromDisk;
 using node::g_indexes_ready_to_sync;
 
 constexpr uint8_t DB_BEST_BLOCK{'B'};
@@ -212,8 +212,6 @@ void BaseIndex::ThreadSync()
 
     const CBlockIndex* pindex = m_best_block_index.load();
     if (!m_synced) {
-        auto& consensus_params = Params().GetConsensus();
-
         auto last_log_time{NodeClock::now()};
         auto last_locator_write_time{last_log_time};
         while (true) {
@@ -246,7 +244,7 @@ void BaseIndex::ThreadSync()
 
             CBlock block;
             interfaces::BlockInfo block_info = kernel::MakeBlockInfo(pindex);
-            if (!ReadBlockFromDisk(block, pindex, consensus_params)) {
+            if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *pindex)) {
                 FatalError("%s: Failed to read block %s from disk",
                            __func__, pindex->GetBlockHash().ToString());
                 return;
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index 2ffec43aaab8..d2aede94ee0e 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -4,6 +4,7 @@
 
 #include <map>
 
+#include <common/args.h>
 #include <dbwrapper.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
@@ -11,11 +12,8 @@
 #include <node/blockstorage.h>
 #include <serialize.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 #include <validation.h>
 
-using node::UndoReadFromDisk;
-
 /* The index database stores three items for each block: the disk location of the encoded filter,
  * its dSHA256 hash, and the header. Those belonging to blocks on the active chain are indexed by
  * height, and those belonging to blocks that have been reorganized out of the active chain are
@@ -273,7 +271,7 @@ bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
         // pindex variable gives indexing code access to node internals. It
         // will be removed in upcoming commit
         const CBlockIndex* pindex = WITH_LOCK(cs_main, return m_chainstate->m_blockman.LookupBlockIndex(block.hash));
-        if (!UndoReadFromDisk(block_undo, pindex)) {
+        if (!m_chainstate->m_blockman.UndoReadFromDisk(block_undo, *pindex)) {
             return false;
         }
 
diff --git a/src/index/coinstatsindex.cpp b/src/index/coinstatsindex.cpp
index 050dd3d0e987..5c81a33ea0cd 100644
--- a/src/index/coinstatsindex.cpp
+++ b/src/index/coinstatsindex.cpp
@@ -4,6 +4,7 @@
 
 #include <chainparams.h>
 #include <coins.h>
+#include <common/args.h>
 #include <crypto/muhash.h>
 #include <index/coinstatsindex.h>
 #include <kernel/coinstats.h>
@@ -12,7 +13,6 @@
 #include <serialize.h>
 #include <txdb.h>
 #include <undo.h>
-#include <util/system.h>
 #include <validation.h>
 #include <util/check.h>
 
@@ -20,9 +20,6 @@ using kernel::CCoinsStats;
 using kernel::GetBogoSize;
 using kernel::TxOutSer;
 
-using node::ReadBlockFromDisk;
-using node::UndoReadFromDisk;
-
 static constexpr uint8_t DB_BLOCK_HASH{'s'};
 static constexpr uint8_t DB_BLOCK_HEIGHT{'t'};
 static constexpr uint8_t DB_MUHASH{'M'};
@@ -127,7 +124,7 @@ bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
 
     // Ignore genesis block
     if (block.height > 0) {
-        if (!UndoReadFromDisk(block_undo, pindex)) {
+        if (!m_chainstate->m_blockman.UndoReadFromDisk(block_undo, *pindex)) {
             return false;
         }
 
@@ -280,12 +277,11 @@ bool CoinStatsIndex::CustomRewind(const interfaces::BlockKey& current_tip, const
         LOCK(cs_main);
         const CBlockIndex* iter_tip{m_chainstate->m_blockman.LookupBlockIndex(current_tip.hash)};
         const CBlockIndex* new_tip_index{m_chainstate->m_blockman.LookupBlockIndex(new_tip.hash)};
-        const auto& consensus_params{Params().GetConsensus()};
 
         do {
             CBlock block;
 
-            if (!ReadBlockFromDisk(block, iter_tip, consensus_params)) {
+            if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *iter_tip)) {
                 LogError("%s: Failed to read block %s from disk\n",
                              __func__, iter_tip->GetBlockHash().ToString());
                 return false;
@@ -411,7 +407,7 @@ bool CoinStatsIndex::ReverseBlock(const CBlock& block, const CBlockIndex* pindex
 
     // Ignore genesis block
     if (pindex->nHeight > 0) {
-        if (!UndoReadFromDisk(block_undo, pindex)) {
+        if (!m_chainstate->m_blockman.UndoReadFromDisk(block_undo, *pindex)) {
             return false;
         }
 
diff --git a/src/index/govcollateralindex.cpp b/src/index/govcollateralindex.cpp
index 64913943b3c9..068101cc4b5a 100644
--- a/src/index/govcollateralindex.cpp
+++ b/src/index/govcollateralindex.cpp
@@ -2,14 +2,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <index/govcollateralindex.h>
-
 #include <chain.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <index/govcollateralindex.h>
 #include <logging.h>
 #include <node/blockstorage.h>
 #include <primitives/block.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <cassert>
@@ -109,7 +108,7 @@ bool GovCollateralIndex::CustomRewind(const interfaces::BlockKey& current_tip, c
     for (const CBlockIndex* pindex{WITH_LOCK(::cs_main, return m_chainstate->m_blockman.LookupBlockIndex(current_tip.hash))};
          pindex != new_tip_index; pindex = pindex->pprev) {
         CBlock block;
-        if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+        if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *pindex)) {
             LogError("%s: Failed to read block %s from disk\n", __func__, pindex->GetBlockHash().ToString());
             return false;
         }
diff --git a/src/index/spentindex.cpp b/src/index/spentindex.cpp
index 06af32143709..47743d46dec0 100644
--- a/src/index/spentindex.cpp
+++ b/src/index/spentindex.cpp
@@ -2,10 +2,12 @@
 // 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 <index/spentindex.h>
 
 #include <chain.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <index/addressindex_util.h>
 #include <logging.h>
 #include <node/blockstorage.h>
@@ -14,7 +16,6 @@
 #include <script/script.h>
 #include <tinyformat.h>
 #include <undo.h>
-#include <util/system.h>
 #include <validation.h>
 
 constexpr uint8_t DB_SPENTINDEX{'p'};
@@ -71,7 +72,7 @@ bool SpentIndex::CustomAppend(const interfaces::BlockInfo& block)
 
     // Read undo data for this block to get information about spent outputs
     CBlockUndo blockundo;
-    if (!node::UndoReadFromDisk(blockundo, pindex)) {
+    if (!m_chainstate->m_blockman.UndoReadFromDisk(blockundo, *pindex)) {
         LogError("%s: Failed to read undo data for block %s at height %d\n", __func__,
                  block.hash.ToString(), block.height);
         return false;
@@ -131,7 +132,7 @@ bool SpentIndex::CustomRewind(const interfaces::BlockKey& current_tip, const int
 
         // Read block to get transactions
         CBlock block;
-        if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+        if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *pindex)) {
             LogError("%s: Failed to read block %s from disk during rewind\n", "CustomRewind",
                      pindex->GetBlockHash().ToString());
             return false;
diff --git a/src/index/timestampindex.cpp b/src/index/timestampindex.cpp
index dca38910eb02..5f6c1044bd37 100644
--- a/src/index/timestampindex.cpp
+++ b/src/index/timestampindex.cpp
@@ -2,12 +2,13 @@
 // 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 <index/timestampindex.h>
 
 #include <chain.h>
+#include <common/system.h>
 #include <logging.h>
 #include <tinyformat.h>
-#include <util/system.h>
 #include <validation.h>
 
 constexpr uint8_t DB_TIMESTAMPINDEX{'s'};
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
index 0baa3f953cbc..ae563b5f2c40 100644
--- a/src/index/txindex.cpp
+++ b/src/index/txindex.cpp
@@ -4,15 +4,13 @@
 
 #include <index/txindex.h>
 
+#include <common/args.h>
 #include <index/disktxpos.h>
 #include <logging.h>
 #include <node/blockstorage.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 #include <validation.h>
 
-using node::OpenBlockFile;
-
 constexpr uint8_t DB_TXINDEX{'t'};
 
 std::unique_ptr<TxIndex> g_txindex;
@@ -81,7 +79,7 @@ bool TxIndex::FindTx(const uint256& tx_hash, uint256& block_hash, CTransactionRe
         return false;
     }
 
-    AutoFile file{OpenBlockFile(postx, true)};
+    AutoFile file{m_chainstate->m_blockman.OpenBlockFile(postx, true)};
     if (file.IsNull()) {
         LogError("%s: OpenBlockFile failed\n", __func__);
         return false;
diff --git a/src/init.cpp b/src/init.cpp
index a29b3c24a8f0..62d7cc259e6c 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -21,7 +21,10 @@
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <context.h>
+#include <chainparamsbase.h>
 #include <consensus/amount.h>
 #include <deploymentstatus.h>
 #include <hash.h>
@@ -57,6 +60,7 @@
 #include <node/context.h>
 #include <node/database_args.h>
 #include <node/interface_ui.h>
+#include <node/kernel_notifications.h>
 #include <node/mempool_args.h>
 #include <node/mempool_persist_args.h>
 #include <node/miner.h>
@@ -83,6 +87,8 @@
 #include <txmempool.h>
 #include <util/asmap.h>
 #include <util/error.h>
+#include <util/chaintype.h>
+#include <util/check.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
 #include <util/moneystr.h>
@@ -90,7 +96,6 @@
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/syserror.h>
-#include <util/system.h>
 #include <util/thread.h>
 #include <util/threadnames.h>
 #include <util/time.h>
@@ -164,20 +169,22 @@
 #endif
 
 using kernel::CoinStatsHashType;
+using kernel::DEFAULT_STOPAFTERBLOCKIMPORT;
 using kernel::DumpMempool;
 using kernel::ValidationCacheSizes;
 
 using node::ApplyArgsManOptions;
+using node::BlockManager;
 using node::CacheSizes;
 using node::CalculateCacheSizes;
 using node::DEFAULT_PERSIST_MEMPOOL;
 using node::DEFAULT_PRINTPRIORITY;
-using node::DEFAULT_STOPAFTERBLOCKIMPORT;
 using node::g_indexes_ready_to_sync;
+using node::KernelNotifications;
 using node::LoadChainstate;
 using node::MempoolPath;
-using node::ShouldPersistMempool;
 using node::NodeContext;
+using node::ShouldPersistMempool;
 using node::ThreadImport;
 using node::VerifyLoadedChainstate;
 using node::fReindex;
@@ -585,14 +592,14 @@ void SetupServerArgs(ArgsManager& argsman)
 
     init::AddLoggingArgs(argsman);
 
-    const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);
-    const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
-    const auto devnetBaseParams = CreateBaseChainParams(CBaseChainParams::DEVNET);
-    const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);
-    const auto defaultChainParams = CreateChainParams(argsman, CBaseChainParams::MAIN);
-    const auto testnetChainParams = CreateChainParams(argsman, CBaseChainParams::TESTNET);
-    const auto devnetChainParams = CreateChainParams(argsman, CBaseChainParams::DEVNET);
-    const auto regtestChainParams = CreateChainParams(argsman, CBaseChainParams::REGTEST);
+    const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
+    const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
+    const auto devnetBaseParams = CreateBaseChainParams(ChainType::DEVNET);
+    const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
+    const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
+    const auto testnetChainParams = CreateChainParams(argsman, ChainType::TESTNET);
+    const auto devnetChainParams = CreateChainParams(argsman, ChainType::DEVNET);
+    const auto regtestChainParams = CreateChainParams(argsman, ChainType::REGTEST);
 
     // Hidden Options
     std::vector<std::string> hidden_args = {"-dbcrashratio", "-forcecompactdb", "-printcrashinfo",
@@ -1200,11 +1207,11 @@ bool AppInitParameterInteraction(const ArgsManager& args)
 
     // Error if network-specific options (-addnode, -connect, etc) are
     // specified in default section of config file, but not overridden
-    // on the command line or in this network's section of the config file.
-    std::string network = args.GetChainName();
+    // on the command line or in this chain's section of the config file.
+    ChainType chain = args.GetChainType();
     bilingual_str errors;
     for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
-        errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section.") + Untranslated("\n"), arg, network, network);
+        errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section.") + Untranslated("\n"), arg, ChainTypeToString(chain), ChainTypeToString(chain));
     }
 
     if (!errors.empty()) {
@@ -1402,7 +1409,7 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         // mempool inconsistencies (see feature_llmq_is_retroactive.py).
         auto stricter{GetStricterThanDefaultRelayPolicy(mempool_opts)};
         if (nBytesPerSigOp > DEFAULT_BYTES_PER_SIGOP) stricter.emplace_back("-bytespersigop");
-        if (!stricter.empty() && chainparams.NetworkIDString() != CBaseChainParams::REGTEST) {
+        if (!stricter.empty() && chainparams.GetChainType() != ChainType::REGTEST) {
             return InitError(
                 strprintf(Untranslated("Masternode must not use a stricter transaction relay policy than the default, "
                                        "which would make it skip InstantSend signing. Remove or restore: %s"),
@@ -1416,15 +1423,18 @@ bool AppInitParameterInteraction(const ArgsManager& args)
 
     // Also report errors from parsing before daemonization
     {
+        KernelNotifications notifications{};
         ChainstateManager::Options chainman_opts_dummy{
             .chainparams = chainparams,
             .datadir = args.GetDataDirNet(),
+            .notifications = notifications,
         };
         if (const auto error{ApplyArgsManOptions(args, chainman_opts_dummy)}) {
             return InitError(*error);
         }
-        node::BlockManager::Options blockman_opts_dummy{
+        BlockManager::Options blockman_opts_dummy{
             .chainparams = chainparams,
+            .blocks_dir = args.GetBlocksDirPath(),
         };
         if (const auto error{ApplyArgsManOptions(args, blockman_opts_dummy)}) {
             return InitError(*error);
@@ -1689,8 +1699,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // as they would never get updated.
     if (!ignores_incoming_txs) {
         bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
-        if (read_stale_estimates && (chainparams.NetworkIDString() != CBaseChainParams::REGTEST)) {
-            return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.NetworkIDString()));
+        if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
+            return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
         }
         node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
 
@@ -1807,7 +1817,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // sanitize comments per BIP-0014, format user agent and check total size
     std::vector<std::string> uacomments;
 
-    if (chainparams.NetworkIDString() == CBaseChainParams::DEVNET) {
+    if (chainparams.GetChainType() == ChainType::DEVNET) {
         // Add devnet name to user agent. This allows to disconnect nodes immediately if they don't belong to our own devnet
         uacomments.push_back(strprintf("devnet.%s", args.GetDevNetName()));
     }
@@ -1937,7 +1947,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 
 #if ENABLE_ZMQ
-    g_zmq_notification_interface = CZMQNotificationInterface::Create();
+    g_zmq_notification_interface = CZMQNotificationInterface::Create(
+        [&chainman = node.chainman](CBlock& block, const CBlockIndex& index) {
+            assert(chainman);
+            return chainman->m_blockman.ReadBlockFromDisk(block, index);
+        });
 
     if (g_zmq_notification_interface) {
         RegisterValidationInterface(g_zmq_notification_interface.get());
@@ -1953,6 +1967,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     // ********************************************************* Step 7b: load block chain
 
+    node.notifications = std::make_unique<KernelNotifications>();
     fReindex = args.GetBoolArg("-reindex", false);
     bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
     ChainstateManager::Options chainman_opts{
@@ -1960,13 +1975,15 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         .datadir = args.GetDataDirNet(),
         .superblock_status = [&sbman = *node.sbman](const CDeterministicMNList& mn_list, int height) { return sbman.GetStatus(mn_list, height); },
         .mn_sync = node.mn_sync.get(),
+        .notifications = *node.notifications,
     };
     Assert(!ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
     DBOptions dash_db_options;
     node::ReadDatabaseArgs(args, dash_db_options);
 
-    node::BlockManager::Options blockman_opts{
+    BlockManager::Options blockman_opts{
         .chainparams = chainparams,
+        .blocks_dir = args.GetBlocksDirPath(),
     };
     Assert(!ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction
 
@@ -2472,7 +2489,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     chainman.m_load_block = std::thread(&util::TraceThread, "loadblk", [=, &args, &chainman, &node] {
         // ThreadImport can switch fReindex from true to false, fetch its original state here to use later
         bool skip_evodb_repair_on_reindex = fReindex || fReindexChainState;
-        ThreadImport(chainman, vImportFiles, args, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{});
+        ThreadImport(chainman, vImportFiles, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{});
 
         {
             const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman.ActiveTip());
@@ -2537,7 +2554,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                     return node.special_tx->RebuildListFromBlock(block, pindexPrev, is_v24_active, prevList,
                                                                                view, debugLogs, state, mnListRet);
                 };
-                auto result = node.dmnman->RecalculateAndRepairDiffs(start_index, stop_index, build_list_func, true);
+                auto result = node.dmnman->RecalculateAndRepairDiffs(chainman.m_blockman, start_index, stop_index, build_list_func, true);
 
                 if (!result.verification_errors.empty()) {
                     LogPrintf("WARNING: Verification errors:\n%s\n", Join(result.verification_errors, "\n"));
diff --git a/src/init/bitcoin-gui.cpp b/src/init/bitcoin-gui.cpp
index e4deb06e490f..35f722b91f95 100644
--- a/src/init/bitcoin-gui.cpp
+++ b/src/init/bitcoin-gui.cpp
@@ -2,6 +2,8 @@
 // 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 <common/system.h>
 #include <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/echo.h>
@@ -10,7 +12,6 @@
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
-#include <util/system.h>
 
 #include <memory>
 
diff --git a/src/init/bitcoin-node.cpp b/src/init/bitcoin-node.cpp
index 01ee2fa8a262..154d901dd4c4 100644
--- a/src/init/bitcoin-node.cpp
+++ b/src/init/bitcoin-node.cpp
@@ -2,6 +2,7 @@
 // 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 <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/echo.h>
@@ -11,7 +12,6 @@
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <util/check.h>
-#include <util/system.h>
 
 #include <memory>
 
diff --git a/src/init/bitcoin-qt.cpp b/src/init/bitcoin-qt.cpp
index 1b75221b1e4f..21bd56d92539 100644
--- a/src/init/bitcoin-qt.cpp
+++ b/src/init/bitcoin-qt.cpp
@@ -2,6 +2,8 @@
 // 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 <common/system.h>
 #include <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/echo.h>
@@ -9,7 +11,6 @@
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
-#include <util/system.h>
 
 #include <memory>
 
diff --git a/src/init/bitcoind.cpp b/src/init/bitcoind.cpp
index 9eedba161e6c..98e973ae40b6 100644
--- a/src/init/bitcoind.cpp
+++ b/src/init/bitcoind.cpp
@@ -2,6 +2,7 @@
 // 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 <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/echo.h>
@@ -10,7 +11,6 @@
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <util/check.h>
-#include <util/system.h>
 
 #include <memory>
 
diff --git a/src/init/common.cpp b/src/init/common.cpp
index 828b11a87d9b..38ace0f66aad 100644
--- a/src/init/common.cpp
+++ b/src/init/common.cpp
@@ -8,6 +8,7 @@
 
 #include <bls/bls.h>
 #include <clientversion.h>
+#include <common/args.h>
 #include <logging.h>
 #include <node/interface_ui.h>
 #include <tinyformat.h>
@@ -15,7 +16,6 @@
 #include <util/fs_helpers.h>
 #include <util/result.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 
diff --git a/src/instantsend/db.cpp b/src/instantsend/db.cpp
index 169e177f34a1..2153ef4a5870 100644
--- a/src/instantsend/db.cpp
+++ b/src/instantsend/db.cpp
@@ -5,9 +5,9 @@
 #include <instantsend/db.h>
 
 #include <chain.h>
+#include <common/system.h>
 #include <dbwrapper.h>
 #include <primitives/block.h>
-#include <util/system.h>
 
 static constexpr std::string_view DB_ARCHIVED_BY_HASH{"is_a2"};
 static constexpr std::string_view DB_ARCHIVED_BY_HEIGHT_AND_HASH{"is_a1"};
diff --git a/src/instantsend/net_instantsend.cpp b/src/instantsend/net_instantsend.cpp
index b5871d326546..edbe314aadab 100644
--- a/src/instantsend/net_instantsend.cpp
+++ b/src/instantsend/net_instantsend.cpp
@@ -25,8 +25,9 @@
 
 // Forward declaration to break dependency over node/transaction.h
 namespace node {
+class BlockManager;
 CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
-                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+                               const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
 } // namespace node
 
 using node::GetTransaction;
@@ -368,7 +369,7 @@ void NetInstantSend::ProcessInstantSendLock(NodeId from, const uint256& hash, co
     if (!m_is_manager.PreVerifyIsLock(hash, islock, from)) return;
 
     uint256 hashBlock{};
-    auto tx = GetTransaction(nullptr, &m_mempool, islock->txid, Params().GetConsensus(), hashBlock);
+    auto tx = GetTransaction(nullptr, &m_mempool, islock->txid, hashBlock, m_chainman.m_blockman);
     const bool found_transaction{tx != nullptr};
     if (found_transaction && islock->inputs != instantsend::GetLockInputs(*tx)) {
         // A lock must pin exactly the transaction's lock inputs. For an asset unlock that is
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 802af1dc11c1..32547a0c811a 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -25,8 +25,9 @@
 
 // Forward declaration to break dependency over node/transaction.h
 namespace node {
+class BlockManager;
 CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
-                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+                               const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
 } // namespace node
 
 using node::GetTransaction;
@@ -128,7 +129,7 @@ void InstantSendSigner::HandleNewInputLockRecoveredSig(const llmq::CRecoveredSig
     }
 
     uint256 _hashBlock{};
-    const auto tx = GetTransaction(nullptr, &m_mempool, txid, Params().GetConsensus(), _hashBlock);
+    const auto tx = GetTransaction(nullptr, &m_mempool, txid, _hashBlock, m_chainman.m_blockman);
     if (!tx) {
         return;
     }
@@ -280,7 +281,7 @@ bool InstantSendSigner::CheckCanLock(const COutPoint& outpoint, bool printDebug,
     }
 
     uint256 hashBlock{};
-    const auto tx = GetTransaction(nullptr, &m_mempool, outpoint.hash, params, hashBlock);
+    const auto tx = GetTransaction(nullptr, &m_mempool, outpoint.hash, hashBlock, m_chainman.m_blockman);
     // this relies on enabled txindex and won't work if we ever try to remove the requirement for txindex for masternodes
     if (!tx || hashBlock.IsNull()) {
         if (printDebug) {
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index bf23fb88db6f..47c1199deeb5 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -6,9 +6,9 @@
 #define BITCOIN_INTERFACES_CHAIN_H
 
 #include <blockfilter.h>
+#include <common/settings.h>
 #include <primitives/transaction.h> // For CTransactionRef
 #include <util/error.h>             // For TransactionError
-#include <util/settings.h>          // For util::SettingsValue
 #include <util/result.h>
 
 #include <functional>
@@ -341,17 +341,17 @@ class Chain
     virtual void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) = 0;
 
     //! Get settings value.
-    virtual util::SettingsValue getSetting(const std::string& arg) = 0;
+    virtual common::SettingsValue getSetting(const std::string& arg) = 0;
 
     //! Get list of settings values.
-    virtual std::vector<util::SettingsValue> getSettingsList(const std::string& arg) = 0;
+    virtual std::vector<common::SettingsValue> getSettingsList(const std::string& arg) = 0;
 
     //! Return <datadir>/settings.json setting value.
-    virtual util::SettingsValue getRwSetting(const std::string& name) = 0;
+    virtual common::SettingsValue getRwSetting(const std::string& name) = 0;
 
     //! Write a setting to <datadir>/settings.json. Optionally just update the
     //! setting in memory and do not write the file.
-    virtual bool updateRwSetting(const std::string& name, const util::SettingsValue& value, bool write=true) = 0;
+    virtual bool updateRwSetting(const std::string& name, const common::SettingsValue& value, bool write=true) = 0;
 
     //! Synchronously send transactionAddedToMempool notifications about all
     //! current mempool transactions to the specified handler and return after
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index e68c2ae8e8f3..559746221f13 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_INTERFACES_NODE_H
 #define BITCOIN_INTERFACES_NODE_H
 
+#include <common/settings.h>
 #include <consensus/amount.h>          // For CAmount
 #include <net.h>                       // For NodeId
 #include <net_types.h>                 // For banmap_t
@@ -15,7 +16,6 @@
 #include <script/script.h>             // For CScript
 #include <support/allocators/secure.h> // For SecureString
 #include <uint256.h>
-#include <util/settings.h>             // For util::SettingsValue
 #include <util/translation.h>
 
 #include <evo/types.h>
@@ -400,14 +400,14 @@ class Node
     virtual bool isSettingIgnored(const std::string& name) = 0;
 
     //! Return setting value from <datadir>/settings.json or dash.conf.
-    virtual util::SettingsValue getPersistentSetting(const std::string& name) = 0;
+    virtual common::SettingsValue getPersistentSetting(const std::string& name) = 0;
 
     //! Update a setting in <datadir>/settings.json.
-    virtual void updateRwSetting(const std::string& name, const util::SettingsValue& value) = 0;
+    virtual void updateRwSetting(const std::string& name, const common::SettingsValue& value) = 0;
 
     //! Force a setting value to be applied, overriding any other configuration
     //! source, but not being persisted.
-    virtual void forceSetting(const std::string& name, const util::SettingsValue& value) = 0;
+    virtual void forceSetting(const std::string& name, const common::SettingsValue& value) = 0;
 
     //! Clear all settings in <datadir>/settings.json and store a backup of
     //! previous settings in <datadir>/settings.json.bak.
diff --git a/src/ipc/interfaces.cpp b/src/ipc/interfaces.cpp
index d804d9d291fb..e446cc98db51 100644
--- a/src/ipc/interfaces.cpp
+++ b/src/ipc/interfaces.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <interfaces/init.h>
 #include <interfaces/ipc.h>
 #include <ipc/capnp/protocol.h>
@@ -10,7 +11,6 @@
 #include <logging.h>
 #include <tinyformat.h>
 #include <util/fs.h>
-#include <util/system.h>
 
 #include <cstdio>
 #include <cstdlib>
diff --git a/src/kernel/blockmanager_opts.h b/src/kernel/blockmanager_opts.h
index 5584a66e0205..83f68cc8d17d 100644
--- a/src/kernel/blockmanager_opts.h
+++ b/src/kernel/blockmanager_opts.h
@@ -5,10 +5,16 @@
 #ifndef BITCOIN_KERNEL_BLOCKMANAGER_OPTS_H
 #define BITCOIN_KERNEL_BLOCKMANAGER_OPTS_H
 
+#include <util/fs.h>
+
+#include <cstdint>
+
 class CChainParams;
 
 namespace kernel {
 
+static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false};
+
 /**
  * An options struct for `BlockManager`, more ergonomically referred to as
  * `BlockManager::Options` due to the using-declaration in `BlockManager`.
@@ -16,6 +22,10 @@ namespace kernel {
 struct BlockManagerOpts {
     const CChainParams& chainparams;
     uint64_t prune_target{0};
+    bool fast_prune{false};
+    bool tiny_blk{false};
+    bool stop_after_block_import{DEFAULT_STOPAFTERBLOCKIMPORT};
+    const fs::path blocks_dir;
 };
 
 } // namespace kernel
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 738140a13184..5f894ffeaf29 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -10,7 +10,6 @@
 #include <util/std23.h>
 
 #include <arith_uint256.h>
-#include <chainparamsbase.h>
 #include <chainparamsseeds.h>
 #include <consensus/amount.h>
 #include <consensus/merkle.h>
@@ -21,8 +20,8 @@
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <uint256.h>
+#include <util/chaintype.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <versionbits.h>
 
 #include <algorithm>
@@ -170,7 +169,7 @@ std::optional<Consensus::LLMQParams> CChainParams::GetLLMQ(Consensus::LLMQType l
 class CMainParams : public CChainParams {
 public:
     CMainParams() {
-        strNetworkID = CBaseChainParams::MAIN;
+        m_chain_type = ChainType::MAIN;
         consensus.nSubsidyHalvingInterval = 210240; // Note: actual number of blocks per calendar year with DGW v3 is ~200700 (for example 449750 - 249050)
         consensus.nMasternodePaymentsStartBlock = 100000; // not true, but it's ok as long as it's less then nMasternodePaymentsIncreaseBlock
         consensus.nMasternodePaymentsIncreaseBlock = 158000; // actual historical value
@@ -304,7 +303,6 @@ class CMainParams : public CChainParams {
 
         fDefaultConsistencyChecks = false;
         fRequireRoutableExternalIP = true;
-        m_is_test_chain = false;
         fAllowMultipleAddressesFromGroup = false;
         nLLMQConnectionRetryTimeout = 60;
         m_is_mockable_chain = false;
@@ -382,7 +380,7 @@ class CMainParams : public CChainParams {
 class CTestNetParams : public CChainParams {
 public:
     CTestNetParams() {
-        strNetworkID = CBaseChainParams::TESTNET;
+        m_chain_type = ChainType::TESTNET;
         consensus.nSubsidyHalvingInterval = 210240;
         consensus.nMasternodePaymentsStartBlock = 4010; // not true, but it's ok as long as it's less then nMasternodePaymentsIncreaseBlock
         consensus.nMasternodePaymentsIncreaseBlock = 4030;
@@ -510,7 +508,6 @@ class CTestNetParams : public CChainParams {
 
         fDefaultConsistencyChecks = false;
         fRequireRoutableExternalIP = true;
-        m_is_test_chain = true;
         fAllowMultipleAddressesFromGroup = false;
         nLLMQConnectionRetryTimeout = 60;
         m_is_mockable_chain = false;
@@ -568,7 +565,7 @@ class CTestNetParams : public CChainParams {
 class CDevNetParams : public CChainParams {
 public:
     explicit CDevNetParams(const DevNetOptions& opts) {
-        strNetworkID = CBaseChainParams::DEVNET;
+        m_chain_type = ChainType::DEVNET;
         consensus.nSubsidyHalvingInterval = 210240;
         consensus.nMasternodePaymentsStartBlock = 4010; // not true, but it's ok as long as it's less then nMasternodePaymentsIncreaseBlock
         consensus.nMasternodePaymentsIncreaseBlock = 4030;
@@ -705,7 +702,6 @@ class CDevNetParams : public CChainParams {
 
         fDefaultConsistencyChecks = false;
         fRequireRoutableExternalIP = true;
-        m_is_test_chain = true;
         fAllowMultipleAddressesFromGroup = true;
         nLLMQConnectionRetryTimeout = 60;
         m_is_mockable_chain = false;
@@ -862,7 +858,7 @@ class CDevNetParams : public CChainParams {
 class CRegTestParams : public CChainParams {
 public:
     explicit CRegTestParams(const RegTestOptions& opts) {
-        strNetworkID =  CBaseChainParams::REGTEST;
+        m_chain_type = ChainType::REGTEST;
         consensus.nSubsidyHalvingInterval = 150;
         consensus.nMasternodePaymentsStartBlock = 240;
         consensus.nMasternodePaymentsIncreaseBlock = 350;
@@ -964,7 +960,6 @@ class CRegTestParams : public CChainParams {
 
         fDefaultConsistencyChecks = true;
         fRequireRoutableExternalIP = false;
-        m_is_test_chain = true;
         fAllowMultipleAddressesFromGroup = true;
         nLLMQConnectionRetryTimeout = 1; // must be lower then the LLMQ signing session timeout so that tests have control over failing behavior
         m_is_mockable_chain = true;
diff --git a/src/kernel/chainparams.h b/src/kernel/chainparams.h
index 777dc15d9627..a96b48821baa 100644
--- a/src/kernel/chainparams.h
+++ b/src/kernel/chainparams.h
@@ -13,6 +13,7 @@
 #include <primitives/block.h>
 #include <protocol.h>
 #include <uint256.h>
+#include <util/chaintype.h>
 #include <util/hash_type.h>
 
 #include <cstdint>
@@ -116,7 +117,7 @@ class CChainParams
     /** If this chain allows time to be mocked */
     bool IsMockableChain() const { return m_is_mockable_chain; }
     /** If this chain is exclusively used for testing */
-    bool IsTestChain() const { return m_is_test_chain; }
+    bool IsTestChain() const { return m_chain_type != ChainType::MAIN; }
     uint64_t PruneAfterHeight() const { return nPruneAfterHeight; }
     /** Block files containing a block-height within MinBlocksToKeep() of ActiveChain().Tip() will not be pruned. */
     int MinBlocksToKeep() const { return m_min_blocks_to_keep; }
@@ -130,8 +131,10 @@ class CChainParams
     bool AllowMultipleAddressesFromGroup() const { return fAllowMultipleAddressesFromGroup; }
     /** How long to wait until we allow retrying of a LLMQ connection  */
     int LLMQConnectionRetryTimeout() const { return nLLMQConnectionRetryTimeout; }
-    /** Return the network string */
-    std::string NetworkIDString() const { return strNetworkID; }
+    /** Return the chain type string */
+    std::string GetChainTypeString() const { return ChainTypeToString(m_chain_type); }
+    /** Return the chain type */
+    ChainType GetChainType() const { return m_chain_type; }
     /** Return the list of hostnames to look up for DNS seeds */
     const std::vector<std::string>& DNSSeeds() const { return vSeeds; }
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
@@ -265,13 +268,12 @@ class CChainParams
     std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
     std::string bech32_platform_hrp;
     int nExtCoinType;
-    std::string strNetworkID;
+    ChainType m_chain_type;
     CBlock genesis;
     CBlock devnetGenesis;
     std::vector<uint8_t> vFixedSeeds;
     bool fDefaultConsistencyChecks;
     bool fRequireRoutableExternalIP;
-    bool m_is_test_chain;
     bool fAllowMultipleAddressesFromGroup;
     bool m_is_mockable_chain;
     int nLLMQConnectionRetryTimeout;
diff --git a/src/kernel/chainstatemanager_opts.h b/src/kernel/chainstatemanager_opts.h
index 6aae1471c304..7fc875f26a30 100644
--- a/src/kernel/chainstatemanager_opts.h
+++ b/src/kernel/chainstatemanager_opts.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_KERNEL_CHAINSTATEMANAGER_OPTS_H
 #define BITCOIN_KERNEL_CHAINSTATEMANAGER_OPTS_H
 
+#include <kernel/notifications_interface.h>
+
 #include <arith_uint256.h>
 #include <dbwrapper.h>
 #include <txdb.h>
@@ -22,6 +24,7 @@ struct SuperblockStatus;
 
 static constexpr bool DEFAULT_CHECKPOINTS_ENABLED{true};
 static constexpr auto DEFAULT_MAX_TIP_AGE{6h}; // ~144 blocks behind -> 2 x fork detection time, was 24h in bitcoin
+static constexpr int DEFAULT_STOPATHEIGHT{0};
 
 namespace kernel {
 
@@ -50,6 +53,8 @@ struct ChainstateManagerOpts {
     DBOptions block_tree_db{};
     DBOptions coins_db{};
     CoinsViewOptions coins_view{};
+    Notifications& notifications;
+    int stop_at_height{DEFAULT_STOPATHEIGHT};
 };
 
 } // namespace kernel
diff --git a/src/kernel/notifications_interface.h b/src/kernel/notifications_interface.h
new file mode 100644
index 000000000000..48248e9aa0b6
--- /dev/null
+++ b/src/kernel/notifications_interface.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
+#define BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
+
+#include <cstdint>
+#include <string>
+
+class CBlockIndex;
+enum class SynchronizationState;
+struct bilingual_str;
+
+namespace kernel {
+
+/**
+ * A base class defining functions for notifying about certain kernel
+ * events.
+ */
+class Notifications
+{
+public:
+    virtual ~Notifications(){};
+
+    virtual void blockTip(SynchronizationState state, CBlockIndex& index) {}
+    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) {}
+};
+} // namespace kernel
+
+#endif // BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
diff --git a/src/llmq/options.cpp b/src/llmq/options.cpp
index 53ab140e1061..3b93c6610336 100644
--- a/src/llmq/options.cpp
+++ b/src/llmq/options.cpp
@@ -2,6 +2,7 @@
 // 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>
@@ -9,9 +10,9 @@
 #include <util/std23.h>
 
 #include <chainparams.h>
+#include <common/system.h>
 #include <consensus/params.h>
 #include <deploymentstatus.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <algorithm>
diff --git a/src/llmq/quorumproofs.cpp b/src/llmq/quorumproofs.cpp
index ad477aa82d10..e23a31160fe5 100644
--- a/src/llmq/quorumproofs.cpp
+++ b/src/llmq/quorumproofs.cpp
@@ -510,7 +510,7 @@ std::vector<CFinalCommitment> QuorumProofBuilder::ActiveCommitments(const CBlock
         hashes.push_back(hash);
     }
     bool mutated{false};
-    Require(ComputeMerkleRoot(hashes, &mutated) == StateAt(index).quorumRoot && !mutated,
+    Require(ComputeMerkleRoot(hashes, &mutated) == StateAt(m_chainman.m_blockman, index).quorumRoot && !mutated,
             "active quorum root mismatch");
     sets.Insert(index->GetBlockHash(), sorted);
     return sorted;
@@ -524,17 +524,17 @@ static ProofCache<ProofState, 256>& StateCache()
 
 void ClearProofStateCacheForTesting() { StateCache().Clear(); }
 
-ProofState QuorumProofBuilder::StateAt(const CBlockIndex* index)
+ProofState QuorumProofBuilder::StateAt(const node::BlockManager& blockman, const CBlockIndex* index)
 {
     Require(index != nullptr && index->nHeight > 0, "invalid checkpoint block");
-    const auto network = Params().NetworkIDString();
+    const auto network = Params().GetChainTypeString();
     Require(network == "main" || network == "test", "proofs support mainnet/testnet");
     // A block hash fixes the coinbase, and the network is fixed for the process.
     // Every request reads the checkpoint's state and the target's more than once.
     ProofState cached;
     if (StateCache().Get(index->GetBlockHash(), cached)) return cached;
     CBlock block;
-    Require(node::ReadBlockFromDisk(block, index, Params().GetConsensus()) && !block.vtx.empty(), "historical block unavailable");
+    Require(blockman.ReadBlockFromDisk(block, *index) && !block.vtx.empty(), "historical block unavailable");
     ProofCertificate cert{uint32_t(index->nHeight), block.GetBlockHeader(), {}};
     auto cb = Coinbase(ProofTransaction::Build(block, 0), cert);
     const ProofState state{uint8_t(network == "main" ? 0 : 1), uint32_t(index->nHeight), index->GetBlockHash(),
@@ -543,7 +543,7 @@ ProofState QuorumProofBuilder::StateAt(const CBlockIndex* index)
     return state;
 }
 
-MasternodeLeaves MasternodeLeavesAt(CDeterministicMNManager& dmnman, const CBlockIndex* index)
+MasternodeLeaves MasternodeLeavesAt(CDeterministicMNManager& dmnman, const node::BlockManager& blockman, const CBlockIndex* index)
 {
     Require(index != nullptr, "missing block index");
     // Every EvoNode record at one target opens the same list, and hashing its
@@ -557,7 +557,7 @@ MasternodeLeaves MasternodeLeavesAt(CDeterministicMNManager& dmnman, const CBloc
     result.leaves.reserve(result.sml->mnList.size());
     for (const auto& entry : result.sml->mnList)
         result.leaves.push_back(entry->CalcHash());
-    const auto root = QuorumProofBuilder::StateAt(index).masternodeRoot;
+    const auto root = QuorumProofBuilder::StateAt(blockman, index).masternodeRoot;
     bool mutated{false};
     Require(ComputeMerkleRoot(result.leaves, &mutated) == root && !mutated, "masternode root mismatch");
     cache.Insert(index->GetBlockHash(), result);
@@ -630,14 +630,14 @@ static const CBlockIndex* MinedCommitmentBlock(const CQuorumBlockProcessor& proc
  *  A miss reads the block and scans its commitments by type and quorum hash
  *  before fully deserializing any payload (a mining block holds dozens of
  *  commitments, each carrying BLS points that are costly to decode). */
-static ProofTransaction MiningTransaction(const CBlockIndex* mined, Consensus::LLMQType kind, const uint256& quorum)
+static ProofTransaction MiningTransaction(const node::BlockManager& blocks, const CBlockIndex* mined, Consensus::LLMQType kind, const uint256& quorum)
 {
     const auto key = (CHashWriter(SER_GETHASH, 0) << mined->GetBlockHash() << kind << quorum).GetHash();
     static ProofCache<ProofTransaction, 2048> cache;
     ProofTransaction cached;
     if (cache.Get(key, cached)) return cached;
     CBlock block;
-    Require(node::ReadBlockFromDisk(block, mined, Params().GetConsensus()), "mining block unavailable");
+    Require(blocks.ReadBlockFromDisk(block, *mined), "mining block unavailable");
     for (size_t i = 1; i < block.vtx.size(); ++i) {
         const auto& tx = *block.vtx[i];
         if (tx.nType != TRANSACTION_QUORUM_COMMITMENT) continue;
@@ -673,7 +673,7 @@ std::optional<QuorumProofChain> QuorumProofBuilder::Build(const CBlockIndex* che
                                 entry.Signed().getSig()};
     };
     QuorumProofChain proof;
-    proof.anchor = StateAt(checkpoint);
+    proof.anchor = StateAt(blocks, checkpoint);
     auto seeds = ActiveCommitments(checkpoint);
     std::set<uint256> seedHashes;
     std::vector<uint256> seedLeaves;
@@ -693,7 +693,7 @@ std::optional<QuorumProofChain> QuorumProofBuilder::Build(const CBlockIndex* che
         const auto* mined = MinedCommitmentBlock(m_quorum_block_processor, m_tip, blocks, kind, needed->quorumHash);
         Require(mined != nullptr, "mining block unavailable");
         if (mined->nHeight <= checkpoint->nHeight) return std::nullopt;
-        const auto mining = MiningTransaction(mined, kind, needed->quorumHash);
+        const auto mining = MiningTransaction(blocks, mined, kind, needed->quorumHash);
         std::optional<ProofLink> best;
         std::optional<CFinalCommitment> predecessor;
         double bestScore = std::numeric_limits<double>::infinity();
@@ -738,9 +738,9 @@ std::optional<QuorumProofChain> QuorumProofBuilder::Build(const CBlockIndex* che
         }
     }
     CBlock finalBlock;
-    Require(node::ReadBlockFromDisk(finalBlock, targetIndex, Params().GetConsensus()), "final block unavailable");
+    Require(blocks.ReadBlockFromDisk(finalBlock, *targetIndex), "final block unavailable");
     proof.coinbase = ProofTransaction::Build(finalBlock, 0);
-    Require(proof.Verify(proof.anchor) == StateAt(targetIndex), "constructed proof does not match chain");
+    Require(proof.Verify(proof.anchor) == StateAt(blocks, targetIndex), "constructed proof does not match chain");
     proof.Encode();
     return proof;
 }
diff --git a/src/llmq/quorumproofs.h b/src/llmq/quorumproofs.h
index e8afff378a93..e97867cb0887 100644
--- a/src/llmq/quorumproofs.h
+++ b/src/llmq/quorumproofs.h
@@ -10,6 +10,9 @@ class CBlockIndex;
 class CDeterministicMNManager;
 class CSimplifiedMNList;
 class ChainstateManager;
+namespace node {
+class BlockManager;
+} // namespace node
 namespace chainlock {
 class CoinbaseChainLockReader;
 struct ChainLockSig;
@@ -66,7 +69,7 @@ struct MasternodeLeaves {
     std::vector<uint256> leaves;
 };
 /** Memoized by block hash once the list hashes to the block's masternode root. */
-MasternodeLeaves MasternodeLeavesAt(CDeterministicMNManager& dmnman, const CBlockIndex* index);
+MasternodeLeaves MasternodeLeavesAt(CDeterministicMNManager& dmnman, const node::BlockManager& blockman, const CBlockIndex* index);
 /** Checkpoint and target states are memoized by block hash; a state read once
  *  stays available even if the block's data is later removed. */
 void ClearProofStateCacheForTesting();
@@ -93,7 +96,7 @@ class QuorumProofBuilder
     {
     }
     std::vector<CFinalCommitment> ActiveCommitments(const CBlockIndex* index) const;
-    static ProofState StateAt(const CBlockIndex* index);
+    static ProofState StateAt(const node::BlockManager& blockman, const CBlockIndex* index);
     /** No value when the target requires a retired checkpoint quorum; other failures throw. */
     std::optional<QuorumProofChain> Build(const CBlockIndex* checkpoint, const chainlock::ChainLockSig& target) const;
 };
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
index e6ceb6eeb7c2..f374d28963cf 100644
--- a/src/llmq/signing.cpp
+++ b/src/llmq/signing.cpp
@@ -10,9 +10,9 @@
 #include <llmq/signhash.h>
 
 #include <chainparams.h>
+#include <common/system.h>
 #include <dbwrapper.h>
 #include <streams.h>
-#include <util/system.h>
 
 #include <algorithm>
 #include <optional>
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 195a050375a1..0d34b0c43dcf 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -27,7 +27,7 @@
 /**
  * Forward declarations
  */
-std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex);
+std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const node::BlockManager& blockman, const CBlockIndex* pindex);
 
 namespace {
 using QuorumMembers = std::vector<CDeterministicMNCPtr>;
@@ -84,9 +84,9 @@ arith_uint256 calculateQuorumScore(const CDeterministicMNCPtr& dmn, const uint25
     return UintToArith256(h);
 }
 
-uint256 GetHashModifierFromWorkBlock(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pWorkBlockIndex)
+uint256 GetHashModifierFromWorkBlock(const Consensus::LLMQParams& llmqParams, const node::BlockManager& blockman, const CBlockIndex* pWorkBlockIndex)
 {
-    auto cbcl = GetNonNullCoinbaseChainlock(pWorkBlockIndex);
+    auto cbcl = GetNonNullCoinbaseChainlock(blockman, pWorkBlockIndex);
     if (cbcl.has_value()) {
         // We have a non-null CL signature: calculate modifier using this CL signature
         auto& [bestCLSignature, bestCLHeightDiff] = cbcl.value();
@@ -97,14 +97,14 @@ uint256 GetHashModifierFromWorkBlock(const Consensus::LLMQParams& llmqParams, co
 }
 
 uint256 GetHashModifier(const Consensus::LLMQParams& llmqParams, const Consensus::Params& consensus_params,
-                        gsl::not_null<const CBlockIndex*> pCycleQuorumBaseBlockIndex)
+                        const node::BlockManager& blockman, gsl::not_null<const CBlockIndex*> pCycleQuorumBaseBlockIndex)
 {
     ASSERT_IF_DEBUG(pCycleQuorumBaseBlockIndex->nHeight % llmqParams.dkgInterval == 0);
     const CBlockIndex* pWorkBlockIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - llmq::WORK_DIFF_DEPTH);
 
     if (DeploymentActiveAfter(pWorkBlockIndex, consensus_params, Consensus::DEPLOYMENT_V20)) {
         // v20 is active: calculate modifier using the new way.
-        return GetHashModifierFromWorkBlock(llmqParams, pWorkBlockIndex);
+        return GetHashModifierFromWorkBlock(llmqParams, blockman, pWorkBlockIndex);
     }
 
     // v20 isn't active yet: calculate modifier using the usual way
@@ -188,6 +188,7 @@ QuorumMembers CalculateQuorum(List&& mn_list, const uint256& modifier, size_t ma
 std::vector<QuorumMembers> GetQuorumQuarterMembersBySnapshot(const Consensus::LLMQParams& llmqParams,
                                                              CDeterministicMNManager& dmnman,
                                                              const Consensus::Params& consensus_params,
+                                                             const node::BlockManager& blockman,
                                                              const CBlockIndex* pCycleQuorumBaseBlockIndex,
                                                              const llmq::CQuorumSnapshot& snapshot, int nHeight)
 {
@@ -201,7 +202,7 @@ std::vector<QuorumMembers> GetQuorumQuarterMembersBySnapshot(const Consensus::LL
         const CBlockIndex* pWorkBlockIndex = pCycleQuorumBaseBlockIndex->GetAncestor(
             pCycleQuorumBaseBlockIndex->nHeight - llmq::WORK_DIFF_DEPTH);
         auto mn_list = dmnman.GetListForBlock(pWorkBlockIndex);
-        const auto modifier = GetHashModifier(llmqParams, consensus_params, pCycleQuorumBaseBlockIndex);
+        const auto modifier = GetHashModifier(llmqParams, consensus_params, blockman, pCycleQuorumBaseBlockIndex);
         auto sortedAllMns = CalculateQuorum(mn_list, modifier);
 
         std::vector<CDeterministicMNCPtr> usedMNs;
@@ -288,7 +289,7 @@ std::vector<QuorumMembers> GetQuorumQuarterMembersBySnapshot(const Consensus::LL
     }
 }
 
-QuorumMembers ComputeQuorumMembers(Consensus::LLMQType llmqType, const CChainParams& chainparams,
+QuorumMembers ComputeQuorumMembers(Consensus::LLMQType llmqType, const CChainParams& chainparams, const node::BlockManager& blockman,
                                    const CDeterministicMNList& mn_list, const CBlockIndex* pQuorumBaseBlockIndex)
 {
     bool EvoOnly = (chainparams.GetConsensus().llmqTypePlatform == llmqType) &&
@@ -300,11 +301,11 @@ QuorumMembers ComputeQuorumMembers(Consensus::LLMQType llmqType, const CChainPar
         return {};
     }
 
-    const auto modifier = GetHashModifier(llmq_params_opt.value(), chainparams.GetConsensus(), pQuorumBaseBlockIndex);
+    const auto modifier = GetHashModifier(llmq_params_opt.value(), chainparams.GetConsensus(), blockman, pQuorumBaseBlockIndex);
     return CalculateQuorum(mn_list, modifier, llmq_params_opt->size, EvoOnly);
 }
 
-void BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const Consensus::Params& consensus_params,
+void BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const Consensus::Params& consensus_params, const node::BlockManager& blockman,
                          const CDeterministicMNList& allMns, const CDeterministicMNList& mnUsedAtH,
                          llmq::CQuorumSnapshot& quorumSnapshot, std::vector<int>& skipList,
                          const CBlockIndex* pCycleQuorumBaseBlockIndex)
@@ -316,7 +317,7 @@ void BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const Consensu
 
     const auto allMnsTotal = allMns.GetCounts().total();
     quorumSnapshot.activeQuorumMembers.resize(allMnsTotal);
-    const auto modifier = GetHashModifier(llmqParams, consensus_params, pCycleQuorumBaseBlockIndex);
+    const auto modifier = GetHashModifier(llmqParams, consensus_params, blockman, pCycleQuorumBaseBlockIndex);
     auto sortedAllMns = CalculateQuorum(allMns, modifier);
 
     LogPrint(BCLog::LLMQ, "BuildQuorumSnapshot h[%d] numMns[%d]\n", pCycleQuorumBaseBlockIndex->nHeight,
@@ -370,7 +371,7 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
     // also works when the cycle base block is not mined yet
     bool skipRemovedMNs = cycleBaseHeight + 1 >=
                               util_params.m_chainman.GetConsensus().DeploymentHeight(Consensus::DEPLOYMENT_V19) ||
-                          (util_params.m_chainman.GetParams().NetworkIDString() == CBaseChainParams::TESTNET);
+                          (util_params.m_chainman.GetParams().GetChainType() == ChainType::TESTNET);
 
     for (const size_t idx : util::irange(nQuorums)) {
         for (auto* prev_cycle : previousQuarters.GetCycles()) {
@@ -457,8 +458,8 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
 
     if (storeSnapshot) {
         llmq::CQuorumSnapshot quorumSnapshot{};
-        BuildQuorumSnapshot(llmqParams, util_params.m_chainman.GetConsensus(), allMns, MnsUsedAtH, quorumSnapshot,
-                            skipList, util_params.m_base_index);
+        BuildQuorumSnapshot(llmqParams, util_params.m_chainman.GetConsensus(), util_params.m_chainman.m_blockman, allMns,
+                            MnsUsedAtH, quorumSnapshot, skipList, util_params.m_base_index);
         util_params.m_qsnapman.StoreSnapshotForBlock(llmqParams.type, util_params.m_base_index, quorumSnapshot);
     }
 
@@ -504,6 +505,7 @@ std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus
         }
         prev_cycles[idx]->m_members = GetQuorumQuarterMembersBySnapshot(llmqParams, util_params.m_dmnman,
                                                                         util_params.m_chainman.GetConsensus(),
+                                                                        util_params.m_chainman.m_blockman,
                                                                         prev_cycles[idx]->m_cycle_index,
                                                                         prev_cycles[idx]->m_snap,
                                                                         cycleBaseHeight);
@@ -611,7 +613,7 @@ std::optional<std::vector<CDeterministicMNCPtr>> ComputeQuorumMembersFromWorkBlo
         return std::nullopt;
     }
 
-    const auto modifier = GetHashModifierFromWorkBlock(llmq_params, pWorkBlockIndex.get());
+    const auto modifier = GetHashModifierFromWorkBlock(llmq_params, util_params.m_chainman.m_blockman, pWorkBlockIndex.get());
 
     if (!llmq_params.useRotation) {
         // Canonical member selection gates EvoOnly on V19 at the future quorum base block; V19
@@ -701,7 +703,7 @@ QuorumMembers GetAllQuorumMembers(Consensus::LLMQType llmqType, const UtilParame
         const CBlockIndex* pWorkBlockIndex = pCycleQuorumBaseBlockIndex->GetAncestor(cycleQuorumBaseHeight -
                                                                                      WORK_DIFF_DEPTH);
         const auto modifier = GetHashModifier(llmq_params, util_params.m_chainman.GetConsensus(),
-                                              pCycleQuorumBaseBlockIndex);
+                                              util_params.m_chainman.m_blockman, pCycleQuorumBaseBlockIndex);
         auto q = ComputeQuorumMembersByQuarterRotation(llmq_params, util_params.replace_index(pCycleQuorumBaseBlockIndex),
                                                        pWorkBlockIndex, cycleQuorumBaseHeight, modifier,
                                                        /*predicting=*/false);
@@ -720,8 +722,8 @@ QuorumMembers GetAllQuorumMembers(Consensus::LLMQType llmqType, const UtilParame
                                                        util_params.m_base_index->nHeight - WORK_DIFF_DEPTH)
                                                  : util_params.m_base_index.get();
         CDeterministicMNList mn_list = util_params.m_dmnman.GetListForBlock(pWorkBlockIndex);
-        quorumMembers = ComputeQuorumMembers(llmqType, util_params.m_chainman.GetParams(), mn_list,
-                                             util_params.m_base_index);
+        quorumMembers = ComputeQuorumMembers(llmqType, util_params.m_chainman.GetParams(), util_params.m_chainman.m_blockman,
+                                             mn_list, util_params.m_base_index);
     }
 
     LOCK(cs_members);
diff --git a/src/mapport.cpp b/src/mapport.cpp
index 464cea73b840..f58d8ced150b 100644
--- a/src/mapport.cpp
+++ b/src/mapport.cpp
@@ -9,11 +9,11 @@
 #include <mapport.h>
 
 #include <clientversion.h>
+#include <common/system.h>
 #include <logging.h>
 #include <net.h>
 #include <netaddress.h>
 #include <netbase.h>
-#include <util/system.h>
 #include <util/thread.h>
 #include <util/threadinterrupt.h>
 
diff --git a/src/masternode/meta.cpp b/src/masternode/meta.cpp
index b4a68634c1ce..c9c3934c4d4a 100644
--- a/src/masternode/meta.cpp
+++ b/src/masternode/meta.cpp
@@ -5,6 +5,7 @@
 #include <masternode/meta.h>
 
 #include <flat-database.h>
+#include <logging.h>
 #include <univalue.h>
 #include <util/time.h>
 
diff --git a/src/masternode/utils.cpp b/src/masternode/utils.cpp
index bb65b23aee35..26f51ad08778 100644
--- a/src/masternode/utils.cpp
+++ b/src/masternode/utils.cpp
@@ -8,6 +8,7 @@
 #include <evo/deterministicmns.h>
 #include <masternode/sync.h>
 
+#include <logging.h>
 #include <net.h>
 #include <shutdown.h>
 
diff --git a/src/net.cpp b/src/net.cpp
index 012f8de5d207..dbf34dbbe5ce 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -15,6 +15,8 @@
 #include <addrman.h>
 #include <banman.h>
 #include <clientversion.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <consensus/consensus.h>
 #include <crypto/sha256.h>
@@ -33,7 +35,6 @@
 #include <util/fs.h>
 #include <util/sock.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/thread.h>
 #include <util/threadinterrupt.h>
 #include <util/time.h>
diff --git a/src/net.h b/src/net.h
index bb3146e7edd9..bfd88be7a5d9 100644
--- a/src/net.h
+++ b/src/net.h
@@ -9,6 +9,7 @@
 #include <bip324.h>
 #include <chainparams.h>
 #include <common/bloom.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <consensus/amount.h>
 #include <consensus/params.h>
@@ -31,7 +32,6 @@
 #include <util/check.h>
 #include <util/edge.h>
 #include <util/sock.h>
-#include <util/system.h>
 #include <util/threadinterrupt.h>
 #include <util/wpipe.h>
 
diff --git a/src/net_permissions.cpp b/src/net_permissions.cpp
index 9cb2e35ac705..814bb7c8bc40 100644
--- a/src/net_permissions.cpp
+++ b/src/net_permissions.cpp
@@ -2,10 +2,10 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <net_permissions.h>
 #include <netbase.h>
 #include <util/error.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 const std::vector<std::string> NET_PERMISSIONS_DOC{
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index d4004d3112bc..9002e875603e 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -10,6 +10,7 @@
 #include <blockencodings.h>
 #include <blockfilter.h>
 #include <chainparams.h>
+#include <common/args.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <hash.h>
@@ -41,7 +42,6 @@
 #include <util/check.h>
 #include <util/std23.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/trace.h>
 #include <validation.h>
 
@@ -79,8 +79,6 @@
 #include <typeinfo>
 #include <vector>
 
-using node::ReadBlockFromDisk;
-
 /** Maximum number of in-flight object requests from a peer. It is not a hard limit, but the
  *  threshold at which point the OVERLOADED_PEER_OBJECT_DELAY kicks in. */
 static constexpr int32_t MAX_PEER_OBJECT_REQUEST_IN_FLIGHT = 100;
@@ -1621,7 +1619,7 @@ void PeerManagerImpl::PushNodeVersion(CNode& pnode, const Peer& peer)
     pnode.SetSentMNAuthChallenge(mnauthChallenge);
 
     int nProtocolVersion = PROTOCOL_VERSION;
-    if (m_chainparams.NetworkIDString() != CBaseChainParams::MAIN && gArgs.IsArgSet("-pushversion")) {
+    if (m_chainparams.GetChainType() != ChainType::MAIN && gArgs.IsArgSet("-pushversion")) {
         nProtocolVersion = gArgs.GetIntArg("-pushversion", PROTOCOL_VERSION);
     }
 
@@ -2889,7 +2887,7 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
     } else {
         // Send block from disk
         std::shared_ptr<CBlock> pblockRead = std::make_shared<CBlock>();
-        const auto hash = ReadBlockFromDisk(*pblockRead, block_pos, m_chainparams.GetConsensus());
+        const auto hash = m_chainman.m_blockman.ReadBlockFromDisk(*pblockRead, block_pos);
         if (!hash || *hash != inv.hash) {
             if (WITH_LOCK(cs_main, return m_chainman.m_blockman.IsBlockPruned(pindex))) {
                 LogPrint(BCLog::NET, "Block was pruned before it could be read, disconnect peer=%d\n", pfrom.GetId());
@@ -4110,7 +4108,7 @@ void PeerManagerImpl::ProcessMessage(
             PushNodeVersion(pfrom, *peer);
         }
 
-        if (m_chainparams.NetworkIDString() == CBaseChainParams::DEVNET) {
+        if (m_chainparams.GetChainType() == ChainType::DEVNET) {
             if (cleanSubVer.find(strprintf("devnet.%s", gArgs.GetDevNetName())) == std::string::npos) {
                 LogPrintf("connected to wrong devnet. Reported version is %s, expected devnet name is %s\n", cleanSubVer, gArgs.GetDevNetName());
                 if (!pfrom.IsInboundConn())
@@ -4831,7 +4829,7 @@ void PeerManagerImpl::ProcessMessage(
 
         if (!block_pos.IsNull()) {
             CBlock block;
-            const auto hash = ReadBlockFromDisk(block, block_pos, m_chainparams.GetConsensus());
+            const auto hash = m_chainman.m_blockman.ReadBlockFromDisk(block, block_pos);
             // If height is above MAX_BLOCKTXN_DEPTH then this block cannot get
             // pruned after we release cs_main above, so this read should never fail.
             assert(hash && *hash == req.blockhash);
@@ -6617,7 +6615,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                         m_connman.PushMessage(pto, std::move(cached_cmpctblock_msg.value()));
                     } else {
                         CBlock block;
-                        bool ret = ReadBlockFromDisk(block, pBestIndex, consensusParams);
+                        const bool ret{m_chainman.m_blockman.ReadBlockFromDisk(block, *pBestIndex)};
                         assert(ret);
                         CBlockHeaderAndShortTxIDs cmpctblock{block};
                         m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::CMPCTBLOCK, cmpctblock));
diff --git a/src/node/blockmanager_args.cpp b/src/node/blockmanager_args.cpp
index 407eefbe09d9..d6ac6f82182a 100644
--- a/src/node/blockmanager_args.cpp
+++ b/src/node/blockmanager_args.cpp
@@ -4,9 +4,15 @@
 
 #include <node/blockmanager_args.h>
 
-#include <util/system.h>
+#include <common/args.h>
+#include <node/blockstorage.h>
+#include <tinyformat.h>
+#include <util/translation.h>
 #include <validation.h>
 
+#include <cstdint>
+#include <optional>
+
 namespace node {
 std::optional<bilingual_str> ApplyArgsManOptions(const ArgsManager& args, BlockManager::Options& opts)
 {
@@ -32,6 +38,10 @@ std::optional<bilingual_str> ApplyArgsManOptions(const ArgsManager& args, BlockM
     }
     opts.prune_target = nPruneTarget;
 
+    if (auto value{args.GetBoolArg("-fastprune")}) opts.fast_prune = *value;
+    if (auto value{args.GetBoolArg("-tinyblk")}) opts.tiny_blk = *value;
+    if (auto value{args.GetBoolArg("-stopafterblockimport")}) opts.stop_after_block_import = *value;
+
     return std::nullopt;
 }
 } // namespace node
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 841896893eb4..5bb1e99fe34c 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -15,9 +15,9 @@
 #include <shutdown.h>
 #include <streams.h>
 #include <undo.h>
+#include <util/batchpriority.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 #include <validation.h>
 #include <walletinitinterface.h>
 
@@ -54,10 +54,6 @@ bool CBlockIndexHeightOnlyComparator::operator()(const CBlockIndex* pa, const CB
     return pa->nHeight < pb->nHeight;
 }
 
-static FILE* OpenUndoFile(const FlatFilePos& pos, bool fReadOnly = false);
-static FlatFileSeq BlockFileSeq();
-static FlatFileSeq UndoFileSeq();
-
 std::vector<CBlockIndex*> BlockManager::GetAllBlockIndices()
 {
     AssertLockHeld(cs_main);
@@ -464,7 +460,7 @@ const CBlockIndex* BlockManager::GetFirstStoredBlock(const CBlockIndex& start_bl
 // rev files since they'll be rewritten by the reindex anyway.  This ensures that m_blockfile_info
 // is in sync with what's actually on disk by the time we start downloading, so that pruning
 // works correctly.
-void CleanupBlockRevFiles()
+void BlockManager::CleanupBlockRevFiles() const
 {
     std::map<std::string, fs::path> mapBlockFiles;
 
@@ -472,8 +468,7 @@ void CleanupBlockRevFiles()
     // Remove the rev files immediately and insert the blk file paths into an
     // ordered map keyed by block file index.
     LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune\n");
-    const fs::path& blocksdir = gArgs.GetBlocksDirPath();
-    for (fs::directory_iterator it(blocksdir); it != fs::directory_iterator(); it++) {
+    for (fs::directory_iterator it(m_opts.blocks_dir); it != fs::directory_iterator(); it++) {
         const std::string path = fs::PathToString(it->path().filename());
         if (fs::is_regular_file(*it) &&
             path.length() == 12 &&
@@ -508,7 +503,7 @@ CBlockFileInfo* BlockManager::GetBlockFileInfo(size_t n)
     return &m_blockfile_info.at(n);
 }
 
-static bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart)
+bool BlockManager::UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart) const
 {
     // Open history file to append
     AutoFile fileout{OpenUndoFile(pos)};
@@ -539,9 +534,9 @@ static bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const
     return true;
 }
 
-bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex)
+bool BlockManager::UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex& index) const
 {
-    const FlatFilePos pos{WITH_LOCK(::cs_main, return pindex->GetUndoPos())};
+    const FlatFilePos pos{WITH_LOCK(::cs_main, return index.GetUndoPos())};
 
     if (pos.IsNull()) {
         LogError("%s: no undo data available\n", __func__);
@@ -559,7 +554,7 @@ bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex)
     uint256 hashChecksum;
     HashVerifier verifier{filein}; // Use HashVerifier as reserializing may lose data, c.f. commit d342424301013ec47dc146a4beb49d5c9319d80a
     try {
-        verifier << pindex->pprev->GetBlockHash();
+        verifier << index.pprev->GetBlockHash();
         verifier >> blockundo;
         filein >> hashChecksum;
     } catch (const std::exception& e) {
@@ -626,7 +621,7 @@ uint64_t BlockManager::CalculateCurrentUsage()
     return retval;
 }
 
-void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune)
+void BlockManager::UnlinkPrunedFiles(const std::set<int>& setFilesToPrune) const
 {
     std::error_code ec;
     for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
@@ -639,30 +634,30 @@ void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune)
     }
 }
 
-static FlatFileSeq BlockFileSeq()
+FlatFileSeq BlockManager::BlockFileSeq() const
 {
-    return FlatFileSeq(gArgs.GetBlocksDirPath(), "blk",
-                       gArgs.GetBoolArg("-fastprune", false) ? 0x4000 /* 16kb */ :
-                        (gArgs.GetBoolArg("-tinyblk", false) ? 0x10000 /* 64kb */ : BLOCKFILE_CHUNK_SIZE));
+    return FlatFileSeq(m_opts.blocks_dir, "blk",
+                       m_opts.fast_prune ? 0x4000 /* 16kb */ :
+                        (m_opts.tiny_blk ? 0x10000 /* 64kb */ : BLOCKFILE_CHUNK_SIZE));
 }
 
-static FlatFileSeq UndoFileSeq()
+FlatFileSeq BlockManager::UndoFileSeq() const
 {
-    return FlatFileSeq(gArgs.GetBlocksDirPath(), "rev", gArgs.GetBoolArg("-tinyblk", false) ? 0x10000 /* 64kb */ : UNDOFILE_CHUNK_SIZE);
+    return FlatFileSeq(m_opts.blocks_dir, "rev", m_opts.tiny_blk ? 0x10000 /* 64kb */ : UNDOFILE_CHUNK_SIZE);
 }
 
-FILE* OpenBlockFile(const FlatFilePos& pos, bool fReadOnly)
+FILE* BlockManager::OpenBlockFile(const FlatFilePos& pos, bool fReadOnly) const
 {
     return BlockFileSeq().Open(pos, fReadOnly);
 }
 
 /** Open an undo file (rev?????.dat) */
-static FILE* OpenUndoFile(const FlatFilePos& pos, bool fReadOnly)
+FILE* BlockManager::OpenUndoFile(const FlatFilePos& pos, bool fReadOnly) const
 {
     return UndoFileSeq().Open(pos, fReadOnly);
 }
 
-fs::path GetBlockPosFilename(const FlatFilePos& pos)
+fs::path BlockManager::GetBlockPosFilename(const FlatFilePos& pos) const
 {
     return BlockFileSeq().FileName(pos);
 }
@@ -681,7 +676,7 @@ bool BlockManager::FindBlockPos(FlatFilePos& pos, unsigned int nAddSize, unsigne
         unsigned int max_blockfile_size{MAX_BLOCKFILE_SIZE};
         // Use smaller blockfiles in test-only -fastprune mode - but avoid
         // the possibility of having a block not fit into the block file.
-        if (gArgs.GetBoolArg("-fastprune", false)) {
+        if (m_opts.fast_prune) {
             max_blockfile_size = 0x10000; // 64kiB
             if (nAddSize >= max_blockfile_size) {
                 // dynamically adjust the blockfile size to be larger than the added size
@@ -768,7 +763,7 @@ bool BlockManager::FindUndoPos(BlockValidationState& state, int nFile, FlatFileP
     return true;
 }
 
-static bool WriteBlockToDisk(const CBlock& block, FlatFilePos& pos, const CMessageHeader::MessageStartChars& messageStart)
+bool BlockManager::WriteBlockToDisk(const CBlock& block, FlatFilePos& pos, const CMessageHeader::MessageStartChars& messageStart) const
 {
     // Open history file to append
     AutoFile fileout{OpenBlockFile(pos)};
@@ -832,7 +827,7 @@ bool BlockManager::WriteUndoDataForBlock(const CBlockUndo& blockundo, BlockValid
     return true;
 }
 
-std::optional<uint256> ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::Params& consensusParams)
+std::optional<uint256> BlockManager::ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos) const
 {
     block.SetNull();
 
@@ -853,7 +848,7 @@ std::optional<uint256> ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos,
 
     // Check the header
     const uint256 hash{block.GetHash()};
-    if (!CheckProofOfWork(hash, block.nBits, consensusParams)) {
+    if (!CheckProofOfWork(hash, block.nBits, GetConsensus())) {
         LogError("ReadBlockFromDisk: Errors in block header at %s\n", pos.ToString());
         return std::nullopt;
     }
@@ -861,17 +856,17 @@ std::optional<uint256> ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos,
     return hash;
 }
 
-bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
+bool BlockManager::ReadBlockFromDisk(CBlock& block, const CBlockIndex& index) const
 {
-    const FlatFilePos block_pos{WITH_LOCK(cs_main, return pindex->GetBlockPos())};
+    const FlatFilePos block_pos{WITH_LOCK(cs_main, return index.GetBlockPos())};
 
-    const auto hash{ReadBlockFromDisk(block, block_pos, consensusParams)};
+    const auto hash{ReadBlockFromDisk(block, block_pos)};
     if (!hash) {
         return false;
     }
-    if (*hash != pindex->GetBlockHash()) {
+    if (*hash != index.GetBlockHash()) {
         LogError("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() doesn't match index for %s at %s\n",
-                     pindex->ToString(), block_pos.ToString());
+                     index.ToString(), block_pos.ToString());
         return false;
     }
     return true;
@@ -920,7 +915,7 @@ class ImportingNow
     }
 };
 
-void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFiles, const ArgsManager& args, const fs::path& mempool_path)
+void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFiles, const fs::path& mempool_path)
 {
     ScheduleBatchPriority();
 
@@ -935,10 +930,10 @@ void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFile
             std::multimap<uint256, FlatFilePos> blocks_with_unknown_parent;
             while (true) {
                 FlatFilePos pos(nFile, 0);
-                if (!fs::exists(GetBlockPosFilename(pos))) {
+                if (!fs::exists(chainman.m_blockman.GetBlockPosFilename(pos))) {
                     break; // No block files left to reindex
                 }
-                FILE* file = OpenBlockFile(pos, true);
+                FILE* file = chainman.m_blockman.OpenBlockFile(pos, true);
                 if (!file) {
                     break; // This error is logged in OpenBlockFile
                 }
@@ -985,7 +980,7 @@ void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFile
             }
         }
 
-        if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {
+        if (chainman.m_blockman.StopAfterBlockImport()) {
             LogPrintf("Stopping after block import\n");
             StartShutdown();
             return;
diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
index 52b7656c39b1..8a06e7788393 100644
--- a/src/node/blockstorage.h
+++ b/src/node/blockstorage.h
@@ -20,7 +20,6 @@
 #include <unordered_map>
 #include <vector>
 
-class ArgsManager;
 class BlockValidationState;
 class CBlock;
 class CBlockUndo;
@@ -34,7 +33,6 @@ struct Params;
 }
 
 namespace node {
-static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false};
 
 /** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
 static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
@@ -104,6 +102,14 @@ class BlockManager
     [[nodiscard]] bool FindBlockPos(FlatFilePos& pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown);
     bool FindUndoPos(BlockValidationState& state, int nFile, FlatFilePos& pos, unsigned int nAddSize);
 
+    FlatFileSeq BlockFileSeq() const;
+    FlatFileSeq UndoFileSeq() const;
+
+    FILE* OpenUndoFile(const FlatFilePos& pos, bool fReadOnly = false) const;
+
+    bool WriteBlockToDisk(const CBlock& block, FlatFilePos& pos, const CMessageHeader::MessageStartChars& messageStart) const;
+    bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart) const;
+
     /* Calculate the block/rev files to delete based on height specified by user with RPC command pruneblockchain */
     void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int nManualPruneHeight, int chain_tip_height);
 
@@ -221,6 +227,8 @@ class BlockManager
 
     [[nodiscard]] bool LoadingBlocks() const { return fImporting || fReindex; }
 
+    [[nodiscard]] bool StopAfterBlockImport() const { return m_opts.stop_after_block_import; }
+
     /** Calculate the amount of disk space the block & undo files currently use */
     uint64_t CalculateCurrentUsage();
 
@@ -238,27 +246,28 @@ class BlockManager
 
     //! Create or update a prune lock identified by its name
     void UpdatePruneLock(const std::string& name, const PruneLockInfo& lock_info) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-};
 
-void CleanupBlockRevFiles();
+    /** Open a block file (blk?????.dat) */
+    FILE* OpenBlockFile(const FlatFilePos& pos, bool fReadOnly = false) const;
 
-/** Open a block file (blk?????.dat) */
-FILE* OpenBlockFile(const FlatFilePos& pos, bool fReadOnly = false);
-/** Translation to a filesystem path */
-fs::path GetBlockPosFilename(const FlatFilePos& pos);
+    /** Translation to a filesystem path */
+    fs::path GetBlockPosFilename(const FlatFilePos& pos) const;
 
-/**
- *  Actually unlink the specified files
- */
-void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune);
+    /**
+     *  Actually unlink the specified files
+     */
+    void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune) const;
 
-/** Functions for disk access for blocks */
-std::optional<uint256> ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::Params& consensusParams);
-bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
+    /** Functions for disk access for blocks */
+    std::optional<uint256> ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos) const;
+    bool ReadBlockFromDisk(CBlock& block, const CBlockIndex& index) const;
 
-bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex);
+    bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex& index) const;
+
+    void CleanupBlockRevFiles() const;
+};
 
-void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFiles, const ArgsManager& args, const fs::path& mempool_path);
+void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFiles, const fs::path& mempool_path);
 } // namespace node
 
 #endif // BITCOIN_NODE_BLOCKSTORAGE_H
diff --git a/src/node/caches.cpp b/src/node/caches.cpp
index 0d0d5e8bd91a..64e79b85f20b 100644
--- a/src/node/caches.cpp
+++ b/src/node/caches.cpp
@@ -2,6 +2,7 @@
 // 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 <node/caches.h>
 
 #include <index/addressindex.h>
@@ -9,7 +10,6 @@
 #include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <txdb.h>
-#include <util/system.h>
 
 namespace node {
 CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes)
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index ef9e312ed0d6..ea001791d571 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -159,7 +159,7 @@ static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager&
         pblocktree->WriteReindexing(true);
         //If we're reindexing in prune mode, wipe away unusable block files and all undo data files
         if (options.prune) {
-            CleanupBlockRevFiles();
+            chainman.m_blockman.CleanupBlockRevFiles();
         }
     }
 
@@ -324,7 +324,7 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
     // persisted snapshot chainstate can no longer be revived. Discard it here
     // rather than letting startup fail with advice ("reindex") the user has
     // just followed, which would never recover.
-    if ((options.reindex || options.reindex_chainstate) && !DeleteSnapshotChainstateFromDisk()) {
+    if ((options.reindex || options.reindex_chainstate) && !DeleteSnapshotChainstateFromDisk(chainman.m_options.datadir)) {
         return {ChainstateLoadStatus::FAILURE,
                 _("Failed to remove the snapshot chainstate directory. Remove it manually before restarting.")};
     }
@@ -417,7 +417,7 @@ ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const C
                 if (notify_bls_state) notify_bls_state(bls::bls_legacy_scheme.load());
             }
 
-            VerifyDBResult result = CVerifyDB().VerifyDB(
+            VerifyDBResult result = CVerifyDB(chainman.GetNotifications()).VerifyDB(
                 *chainstate, chainman.GetConsensus(), chainstate->CoinsDB(),
                 evodb,
                 options.check_level,
diff --git a/src/node/chainstatemanager_args.cpp b/src/node/chainstatemanager_args.cpp
index 9801e6e959d2..40d1c9540157 100644
--- a/src/node/chainstatemanager_args.cpp
+++ b/src/node/chainstatemanager_args.cpp
@@ -5,13 +5,13 @@
 #include <node/chainstatemanager_args.h>
 
 #include <arith_uint256.h>
+#include <common/args.h>
 #include <kernel/chainstatemanager_opts.h>
 #include <node/coins_view_args.h>
 #include <node/database_args.h>
 #include <tinyformat.h>
 #include <uint256.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 
@@ -37,6 +37,8 @@ std::optional<bilingual_str> ApplyArgsManOptions(const ArgsManager& args, Chains
 
     if (auto value{args.GetIntArg("-maxtipage")}) opts.max_tip_age = std::chrono::seconds{*value};
 
+    if (auto value{args.GetIntArg("-stopatheight")}) opts.stop_at_height = *value;
+
     ReadDatabaseArgs(args, opts.block_tree_db);
     ReadDatabaseArgs(args, opts.coins_db);
     ReadCoinsViewArgs(args, opts.coins_view);
diff --git a/src/node/coins_view_args.cpp b/src/node/coins_view_args.cpp
index 67c9b8dbacf4..5d55143e8325 100644
--- a/src/node/coins_view_args.cpp
+++ b/src/node/coins_view_args.cpp
@@ -4,8 +4,8 @@
 
 #include <node/coins_view_args.h>
 
+#include <common/args.h>
 #include <txdb.h>
-#include <util/system.h>
 
 namespace node {
 void ReadCoinsViewArgs(const ArgsManager& args, CoinsViewOptions& options)
diff --git a/src/node/context.cpp b/src/node/context.cpp
index 695092a2bfc6..8e6b30bf9b74 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -12,6 +12,7 @@
 #include <netfulfilledman.h>
 #include <net_processing.h>
 #include <netgroup.h>
+#include <node/kernel_notifications.h>
 #include <policy/fees.h>
 #include <scheduler.h>
 #include <txmempool.h>
diff --git a/src/node/context.h b/src/node/context.h
index ad8629f73d35..eb72fdb2ddd7 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -67,6 +67,8 @@ struct ObserverContext;
 } // namespace llmq
 
 namespace node {
+class KernelNotifications;
+
 //! NodeContext struct containing references to chain state and connection
 //! state.
 //!
@@ -101,6 +103,7 @@ struct NodeContext {
     std::unique_ptr<CScheduler> scheduler;
     std::function<void()> rpc_interruption_point = [] {};
     std::atomic<int> exit_status{EXIT_SUCCESS};
+    std::unique_ptr<KernelNotifications> notifications;
     //! Dash managers
     std::unique_ptr<CJWalletManager> cj_walletman;
     std::unique_ptr<CDSTXManager> dstxman;
diff --git a/src/node/database_args.cpp b/src/node/database_args.cpp
index 2c53b4b47e4d..aba3c38ff3f1 100644
--- a/src/node/database_args.cpp
+++ b/src/node/database_args.cpp
@@ -4,8 +4,8 @@
 
 #include <node/database_args.h>
 
+#include <common/args.h>
 #include <dbwrapper.h>
-#include <util/system.h>
 
 namespace node {
 void ReadDatabaseArgs(const ArgsManager& args, DBOptions& options)
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index f459b8181f69..a12196d561e9 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -2,6 +2,7 @@
 // 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 <interfaces/node.h>
 
 #include <addrdb.h>
@@ -11,6 +12,7 @@
 #include <chainlock/chainlock.h>
 #include <chainparams.h>
 #include <coinjoin/common.h>
+#include <common/system.h>
 #include <deploymentstatus.h>
 #include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
@@ -64,7 +66,6 @@
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/check.h>
-#include <util/system.h>
 #include <util/result.h>
 #include <util/translation.h>
 #include <validation.h>
@@ -943,17 +944,17 @@ class NodeImpl : public Node
     bool isSettingIgnored(const std::string& name) override
     {
         bool ignored = false;
-        args().LockSettings([&](util::Settings& settings) {
-            if (auto* options = util::FindKey(settings.command_line_options, name)) {
+        args().LockSettings([&](common::Settings& settings) {
+            if (auto* options = common::FindKey(settings.command_line_options, name)) {
                 ignored = !options->empty();
             }
         });
         return ignored;
     }
-    util::SettingsValue getPersistentSetting(const std::string& name) override { return args().GetPersistentSetting(name); }
-    void updateRwSetting(const std::string& name, const util::SettingsValue& value) override
+    common::SettingsValue getPersistentSetting(const std::string& name) override { return args().GetPersistentSetting(name); }
+    void updateRwSetting(const std::string& name, const common::SettingsValue& value) override
     {
-        args().LockSettings([&](util::Settings& settings) {
+        args().LockSettings([&](common::Settings& settings) {
             if (value.isNull()) {
                 settings.rw_settings.erase(name);
             } else {
@@ -962,9 +963,9 @@ class NodeImpl : public Node
         });
         args().WriteSettingsFile();
     }
-    void forceSetting(const std::string& name, const util::SettingsValue& value) override
+    void forceSetting(const std::string& name, const common::SettingsValue& value) override
     {
-        args().LockSettings([&](util::Settings& settings) {
+        args().LockSettings([&](common::Settings& settings) {
             if (value.isNull()) {
                 settings.forced_settings.erase(name);
             } else {
@@ -975,7 +976,7 @@ class NodeImpl : public Node
     void resetSettings() override
     {
         args().WriteSettingsFile(/*errors=*/nullptr, /*backup=*/true);
-        args().LockSettings([&](util::Settings& settings) {
+        args().LockSettings([&](common::Settings& settings) {
             settings.rw_settings.clear();
         });
         args().WriteSettingsFile();
@@ -1057,7 +1058,7 @@ class NodeImpl : public Node
         std::vector<ExternalSigner> signers = {};
         const std::string command = args().GetArg("-signer", "");
         if (command == "") return {};
-        ExternalSigner::Enumerate(command, signers, Params().NetworkIDString());
+        ExternalSigner::Enumerate(command, signers, Params().GetChainTypeString());
         std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
         result.reserve(signers.size());
         for (auto& signer : signers) {
@@ -1277,7 +1278,7 @@ class NodeImpl : public Node
     NodeContext* m_context{nullptr};
 };
 
-bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active)
+bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman)
 {
     if (!index) return false;
     if (block.m_hash) *block.m_hash = index->GetBlockHash();
@@ -1287,10 +1288,10 @@ bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<Rec
     if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
     if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
     if (block.m_locator) { *block.m_locator = GetLocator(index); }
-    if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active);
+    if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active, blockman);
     if (block.m_data) {
         REVERSE_LOCK(lock);
-        if (!ReadBlockFromDisk(*block.m_data, index, Params().GetConsensus())) block.m_data->SetNull();
+        if (!blockman.ReadBlockFromDisk(*block.m_data, *index)) block.m_data->SetNull();
     }
     block.found = true;
     return true;
@@ -1493,13 +1494,13 @@ class ChainImpl : public Chain
     bool findBlock(const uint256& hash, const FoundBlock& block) override
     {
         WAIT_LOCK(cs_main, lock);
-        return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain());
+        return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain(), chainman().m_blockman);
     }
     bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
     {
         WAIT_LOCK(cs_main, lock);
         const CChain& active = chainman().ActiveChain();
-        return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active);
+        return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active, chainman().m_blockman);
     }
     bool findAncestorByHeight(const uint256& block_hash, int ancestor_height, const FoundBlock& ancestor_out) override
     {
@@ -1507,10 +1508,10 @@ class ChainImpl : public Chain
         const CChain& active = chainman().ActiveChain();
         if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
             if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
-                return FillBlock(ancestor, ancestor_out, lock, active);
+                return FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman);
             }
         }
-        return FillBlock(nullptr, ancestor_out, lock, active);
+        return FillBlock(nullptr, ancestor_out, lock, active, chainman().m_blockman);
     }
     bool findAncestorByHash(const uint256& block_hash, const uint256& ancestor_hash, const FoundBlock& ancestor_out) override
     {
@@ -1518,7 +1519,7 @@ class ChainImpl : public Chain
         const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash);
         const CBlockIndex* ancestor = chainman().m_blockman.LookupBlockIndex(ancestor_hash);
         if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
-        return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain());
+        return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain(), chainman().m_blockman);
     }
     bool findCommonAncestor(const uint256& block_hash1, const uint256& block_hash2, const FoundBlock& ancestor_out, const FoundBlock& block1_out, const FoundBlock& block2_out) override
     {
@@ -1530,9 +1531,9 @@ class ChainImpl : public Chain
         // Using & instead of && below to avoid short circuiting and leaving
         // output uninitialized. Cast bool to int to avoid -Wbitwise-instead-of-logical
         // compiler warnings.
-        return int{FillBlock(ancestor, ancestor_out, lock, active)} &
-               int{FillBlock(block1, block1_out, lock, active)} &
-               int{FillBlock(block2, block2_out, lock, active)};
+        return int{FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman)} &
+               int{FillBlock(block1, block1_out, lock, active, chainman().m_blockman)} &
+               int{FillBlock(block2, block2_out, lock, active, chainman().m_blockman)};
     }
     void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
     double guessVerificationProgress(const uint256& block_hash) override
@@ -1678,27 +1679,27 @@ class ChainImpl : public Chain
     {
         RPCRunLater(name, std::move(fn), seconds);
     }
-    util::SettingsValue getSetting(const std::string& name) override
+    common::SettingsValue getSetting(const std::string& name) override
     {
         return args().GetSetting(name);
     }
-    std::vector<util::SettingsValue> getSettingsList(const std::string& name) override
+    std::vector<common::SettingsValue> getSettingsList(const std::string& name) override
     {
         return args().GetSettingsList(name);
     }
-    util::SettingsValue getRwSetting(const std::string& name) override
+    common::SettingsValue getRwSetting(const std::string& name) override
     {
-        util::SettingsValue result;
-        args().LockSettings([&](const util::Settings& settings) {
-            if (const util::SettingsValue* value = util::FindKey(settings.rw_settings, name)) {
+        common::SettingsValue result;
+        args().LockSettings([&](const common::Settings& settings) {
+            if (const common::SettingsValue* value = common::FindKey(settings.rw_settings, name)) {
                 result = *value;
             }
         });
         return result;
     }
-    bool updateRwSetting(const std::string& name, const util::SettingsValue& value, bool write) override
+    bool updateRwSetting(const std::string& name, const common::SettingsValue& value, bool write) override
     {
-        args().LockSettings([&](util::Settings& settings) {
+        args().LockSettings([&](common::Settings& settings) {
             if (value.isNull()) {
                 settings.rw_settings.erase(name);
             } else {
diff --git a/src/node/kernel_notifications.cpp b/src/node/kernel_notifications.cpp
new file mode 100644
index 000000000000..f9010a065133
--- /dev/null
+++ b/src/node/kernel_notifications.cpp
@@ -0,0 +1,75 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <node/kernel_notifications.h>
+
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+
+#include <common/args.h>
+#include <common/system.h>
+#include <node/interface_ui.h>
+#include <util/strencodings.h>
+#include <util/string.h>
+#include <util/translation.h>
+#include <warnings.h>
+
+#include <cstdint>
+#include <string>
+#include <thread>
+
+static void AlertNotify(const std::string& strMessage)
+{
+    uiInterface.NotifyAlertChanged();
+#if HAVE_SYSTEM
+    std::string strCmd = gArgs.GetArg("-alertnotify", "");
+    if (strCmd.empty()) return;
+
+    // Alert text should be plain ascii coming from a trusted source, but to
+    // be safe we first strip anything not in safeChars, then add single quotes around
+    // the whole string before passing it to the shell:
+    std::string singleQuote("'");
+    std::string safeStatus = SanitizeString(strMessage);
+    safeStatus = singleQuote+safeStatus+singleQuote;
+    ReplaceAll(strCmd, "%s", safeStatus);
+
+    std::thread t(runCommand, strCmd);
+    t.detach(); // thread runs free
+#endif
+}
+
+static void DoWarning(const bilingual_str& warning)
+{
+    static bool fWarned = false;
+    SetMiscWarning(warning);
+    if (!fWarned) {
+        AlertNotify(warning.original);
+        fWarned = true;
+    }
+}
+
+namespace node {
+
+void KernelNotifications::blockTip(SynchronizationState state, CBlockIndex& index)
+{
+    uiInterface.NotifyBlockTip(state, &index);
+}
+
+void KernelNotifications::headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync)
+{
+    uiInterface.NotifyHeaderTip(state, height, timestamp);
+}
+
+void KernelNotifications::progress(const bilingual_str& title, int progress_percent, bool resume_possible)
+{
+    uiInterface.ShowProgress(title.translated, progress_percent, resume_possible);
+}
+
+void KernelNotifications::warning(const bilingual_str& warning)
+{
+    DoWarning(warning);
+}
+
+} // namespace node
diff --git a/src/node/kernel_notifications.h b/src/node/kernel_notifications.h
new file mode 100644
index 000000000000..3e665bbf14e5
--- /dev/null
+++ b/src/node/kernel_notifications.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_NODE_KERNEL_NOTIFICATIONS_H
+#define BITCOIN_NODE_KERNEL_NOTIFICATIONS_H
+
+#include <kernel/notifications_interface.h>
+
+#include <cstdint>
+#include <string>
+
+class CBlockIndex;
+enum class SynchronizationState;
+struct bilingual_str;
+
+namespace node {
+class KernelNotifications : public kernel::Notifications
+{
+public:
+    void blockTip(SynchronizationState state, CBlockIndex& index) override;
+
+    void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override;
+
+    void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override;
+
+    void warning(const bilingual_str& warning) override;
+};
+} // namespace node
+
+#endif // BITCOIN_NODE_KERNEL_NOTIFICATIONS_H
diff --git a/src/node/mempool_args.cpp b/src/node/mempool_args.cpp
index 800312abc896..26b5b895b851 100644
--- a/src/node/mempool_args.cpp
+++ b/src/node/mempool_args.cpp
@@ -2,6 +2,7 @@
 // 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 <node/mempool_args.h>
 
 #include <index/addressindex.h>
@@ -18,7 +19,6 @@
 #include <tinyformat.h>
 #include <util/error.h>
 #include <util/moneystr.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <chrono>
@@ -90,7 +90,7 @@ std::optional<bilingual_str> ApplyArgsManOptions(const ArgsManager& argsman, con
 
     mempool_opts.require_standard = !argsman.GetBoolArg("-acceptnonstdtxn", DEFAULT_ACCEPT_NON_STD_TXN);
     if (!chainparams.IsTestChain() && !mempool_opts.require_standard) {
-        return strprintf(Untranslated("acceptnonstdtxn is not currently supported for %s chain"), chainparams.NetworkIDString());
+        return strprintf(Untranslated("acceptnonstdtxn is not currently supported for %s chain"), chainparams.GetChainTypeString());
     }
 
     ApplyArgsManOptions(argsman, mempool_opts.limits);
diff --git a/src/node/mempool_persist_args.cpp b/src/node/mempool_persist_args.cpp
index 78e3472644fb..97ecdd651bcd 100644
--- a/src/node/mempool_persist_args.cpp
+++ b/src/node/mempool_persist_args.cpp
@@ -4,8 +4,8 @@
 
 #include <node/mempool_persist_args.h>
 
+#include <common/args.h>
 #include <util/fs.h>
-#include <util/system.h>
 #include <validation.h>
 
 namespace node {
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 75fb1e8fa05a..ca84a4b531da 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -4,6 +4,7 @@
 // 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 <node/miner.h>
 
 #include <chain.h>
@@ -22,7 +23,6 @@
 #include <primitives/transaction.h>
 #include <timedata.h>
 #include <util/moneystr.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <chainlock/chainlock.h>
@@ -114,7 +114,7 @@ void BlockAssembler::resetBlock()
 }
 
 // Helper to calculate best chainlock
-static bool CalcCbTxBestChainlock(const chainlock::Chainlocks& chainlocks, const CBlockIndex* pindexPrev,
+static bool CalcCbTxBestChainlock(const chainlock::Chainlocks& chainlocks, const node::BlockManager& blockman, const CBlockIndex* pindexPrev,
                                   uint32_t& bestCLHeightDiff, CBLSSignature& bestCLSignature)
 {
     auto best_clsig = chainlocks.GetBestChainLock();
@@ -129,7 +129,7 @@ static bool CalcCbTxBestChainlock(const chainlock::Chainlocks& chainlocks, const
         return true;
     }
 
-    auto prevBlockCoinbaseChainlock = GetNonNullCoinbaseChainlock(pindexPrev);
+    auto prevBlockCoinbaseChainlock = GetNonNullCoinbaseChainlock(blockman, pindexPrev);
     if (prevBlockCoinbaseChainlock.has_value()) {
         // Previous block Coinbase contains a non-null CL: We must insert the same sig or a better (newest) one
         if (best_clsig.IsNull()) {
@@ -254,7 +254,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     pblock->nVersion = m_chainstate.m_chainman.m_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // Non-mainnet only: allow overriding block.nVersion with
     // -blockversion=N to test forking scenarios
-    if (chainparams.NetworkIDString() != CBaseChainParams::MAIN) {
+    if (chainparams.GetChainType() != ChainType::MAIN) {
         pblock->nVersion = gArgs.GetIntArg("-blockversion", pblock->nVersion);
     }
 
@@ -355,7 +355,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
             }
             if (fV20Active_context) {
                 CBLSSignature best_cl_sig;
-                const bool has_best_cl{CalcCbTxBestChainlock(m_chainlocks, pindexPrev, cbTx.bestCLHeightDiff, best_cl_sig)};
+                const bool has_best_cl{CalcCbTxBestChainlock(m_chainlocks, m_chainstate.m_blockman, pindexPrev, cbTx.bestCLHeightDiff, best_cl_sig)};
                 cbTx.bestCLSignature.Set(best_cl_sig, bls::bls_legacy_scheme.load());
                 if (has_best_cl) {
                     LogPrintf("CreateNewBlock() h[%d] CbTx bestCLHeightDiff[%d] CLSig[%s]\n", nHeight, cbTx.bestCLHeightDiff, cbTx.bestCLSignature.ToString());
diff --git a/src/node/peerman_args.cpp b/src/node/peerman_args.cpp
index ab372f75d12d..205507dcb385 100644
--- a/src/node/peerman_args.cpp
+++ b/src/node/peerman_args.cpp
@@ -1,7 +1,7 @@
 #include <node/peerman_args.h>
 
 #include <net_processing.h>
-#include <util/system.h>
+#include <common/args.h>
 
 #include <algorithm>
 #include <limits>
diff --git a/src/node/sync_manager.cpp b/src/node/sync_manager.cpp
index c8159d2d6b55..1573e25c21d0 100644
--- a/src/node/sync_manager.cpp
+++ b/src/node/sync_manager.cpp
@@ -5,6 +5,7 @@
 #include <node/sync_manager.h>
 
 #include <chainparams.h>
+#include <common/args.h>
 #include <evo/deterministicmns.h>
 #include <governance/governance.h>
 #include <logging.h>
@@ -73,7 +74,7 @@ int SyncManager::RequestGovernanceObjectVotes(const std::vector<CNode*>& vNodesC
     // On mainnet nMaxObjRequestsPerNode is always set to 1.
     int nMaxObjRequestsPerNode = 1;
     size_t nProjectedVotes = 2000;
-    if (Params().NetworkIDString() != CBaseChainParams::MAIN) {
+    if (Params().GetChainType() != ChainType::MAIN) {
         nMaxObjRequestsPerNode =
             std::max(1, int(nProjectedVotes /
                             std::max(1, (int)m_gov_manager.GetMNManager().GetListAtChainTip().GetCounts().enabled())));
diff --git a/src/node/transaction.cpp b/src/node/transaction.cpp
index 51cc1fd8e46e..c2eb4b4cdf4c 100644
--- a/src/node/transaction.cpp
+++ b/src/node/transaction.cpp
@@ -123,7 +123,7 @@ TransactionError BroadcastTransaction(NodeContext& node, const CTransactionRef t
     return TransactionError::OK;
 }
 
-CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock)
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, uint256& hashBlock, const BlockManager& blockman)
 {
     if (mempool && !block_index) {
         CTransactionRef ptx = mempool->get(hash);
@@ -144,7 +144,7 @@ CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMe
     }
     if (block_index) {
         CBlock block;
-        if (ReadBlockFromDisk(block, block_index, consensusParams)) {
+        if (blockman.ReadBlockFromDisk(block, *block_index)) {
             for (const auto& tx : block.vtx) {
                 if (tx->GetHash() == hash) {
                     hashBlock = block_index->GetBlockHash();
diff --git a/src/node/transaction.h b/src/node/transaction.h
index 8a6778586bf7..18d465384bb4 100644
--- a/src/node/transaction.h
+++ b/src/node/transaction.h
@@ -16,6 +16,7 @@ struct Params;
 }
 
 namespace node {
+class BlockManager;
 struct NodeContext;
 
 /** Maximum fee rate for sendrawtransaction and testmempoolaccept RPC calls.
@@ -52,11 +53,10 @@ static const CFeeRate DEFAULT_MAX_RAW_TX_FEE_RATE{COIN / 10};
  * @param[in]  block_index     The block to read from disk, or nullptr
  * @param[in]  mempool         If provided, check mempool for tx
  * @param[in]  hash            The txid
- * @param[in]  consensusParams The params
  * @param[out] hashBlock       The block hash, if the tx was found via -txindex or block_index
  * @returns                    The tx if found, otherwise nullptr
  */
-CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
 } // namespace node
 
 #endif // BITCOIN_NODE_TRANSACTION_H
diff --git a/src/node/txreconciliation.cpp b/src/node/txreconciliation.cpp
index ed04a78cecfa..d62046daaaa6 100644
--- a/src/node/txreconciliation.cpp
+++ b/src/node/txreconciliation.cpp
@@ -4,8 +4,9 @@
 
 #include <node/txreconciliation.h>
 
+#include <common/system.h>
+#include <logging.h>
 #include <util/check.h>
-#include <util/system.h>
 
 #include <unordered_map>
 #include <variant>
diff --git a/src/node/utxo_snapshot.cpp b/src/node/utxo_snapshot.cpp
index 08a6976aadb9..3498e86203e6 100644
--- a/src/node/utxo_snapshot.cpp
+++ b/src/node/utxo_snapshot.cpp
@@ -4,6 +4,7 @@
 
 #include <node/utxo_snapshot.h>
 
+#include <common/system.h>
 #include <logging.h>
 #include <streams.h>
 #include <sync.h>
@@ -12,7 +13,6 @@
 #include <uint256.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <cassert>
@@ -90,10 +90,10 @@ std::optional<uint256> ReadSnapshotBaseBlockhash(fs::path chaindir)
     return base_blockhash;
 }
 
-std::optional<fs::path> FindSnapshotChainstateDir()
+std::optional<fs::path> FindSnapshotChainstateDir(const fs::path& data_dir)
 {
     fs::path possible_dir =
-        gArgs.GetDataDirNet() / fs::u8path(strprintf("chainstate%s", SNAPSHOT_CHAINSTATE_SUFFIX));
+        data_dir / fs::u8path(strprintf("chainstate%s", SNAPSHOT_CHAINSTATE_SUFFIX));
 
     if (fs::exists(possible_dir)) {
         return possible_dir;
diff --git a/src/node/utxo_snapshot.h b/src/node/utxo_snapshot.h
index 62cc4c55c82b..8ce0e4fee0d4 100644
--- a/src/node/utxo_snapshot.h
+++ b/src/node/utxo_snapshot.h
@@ -75,7 +75,7 @@ constexpr std::string_view SNAPSHOT_TODELETE_SUFFIX = "_todelete";
 
 
 //! Return a path to the snapshot-based chainstate dir, if one exists.
-std::optional<fs::path> FindSnapshotChainstateDir();
+std::optional<fs::path> FindSnapshotChainstateDir(const fs::path& data_dir);
 
 } // namespace node
 
diff --git a/src/node/validation_cache_args.cpp b/src/node/validation_cache_args.cpp
index e13b7988a09a..79c035b469c0 100644
--- a/src/node/validation_cache_args.cpp
+++ b/src/node/validation_cache_args.cpp
@@ -6,7 +6,7 @@
 
 #include <kernel/validation_cache_sizes.h>
 
-#include <util/system.h>
+#include <common/args.h>
 
 #include <algorithm>
 #include <cstddef>
diff --git a/src/policy/fees.cpp b/src/policy/fees.cpp
index edc89c54e0c4..c4f59aee0c90 100644
--- a/src/policy/fees.cpp
+++ b/src/policy/fees.cpp
@@ -6,6 +6,7 @@
 #include <policy/fees.h>
 
 #include <clientversion.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <kernel/mempool_entry.h>
 #include <logging.h>
@@ -19,7 +20,6 @@
 #include <uint256.h>
 #include <util/fs.h>
 #include <util/serfloat.h>
-#include <util/system.h>
 #include <util/time.h>
 
 #include <algorithm>
diff --git a/src/policy/fees_args.cpp b/src/policy/fees_args.cpp
index 1aeb2ab98300..988b6d443a5d 100644
--- a/src/policy/fees_args.cpp
+++ b/src/policy/fees_args.cpp
@@ -4,7 +4,7 @@
 
 #include <policy/fees_args.h>
 
-#include <util/system.h>
+#include <common/args.h>
 
 namespace {
 const char* FEE_ESTIMATES_FILENAME = "fee_estimates.dat";
diff --git a/src/protocol.cpp b/src/protocol.cpp
index f27f00bf835b..c672016c3538 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -5,7 +5,7 @@
 
 #include <protocol.h>
 
-#include <util/system.h>
+#include <common/system.h>
 
 #include <atomic>
 
diff --git a/src/qt/appearancewidget.cpp b/src/qt/appearancewidget.cpp
index 7cba5922dccd..3f47719ea30f 100644
--- a/src/qt/appearancewidget.cpp
+++ b/src/qt/appearancewidget.cpp
@@ -12,7 +12,7 @@
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 
-#include <util/system.h>
+#include <common/system.h>
 
 #include <QComboBox>
 #include <QDataWidgetMapper>
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index fb598416f066..3660342a6015 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -10,7 +10,9 @@
 #include <qt/bitcoin.h>
 
 #include <chainparams.h>
+#include <common/args.h>
 #include <common/init.h>
+#include <common/system.h>
 #include <init.h>
 #include <interfaces/handler.h>
 #include <interfaces/init.h>
@@ -36,7 +38,6 @@
 #include <util/exception.h>
 #include <util/fs.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
 #include <validation.h>
@@ -518,7 +519,7 @@ int GuiMain(int argc, char* argv[])
     RegisterPrettySignalHandlers();
 
 #ifdef WIN32
-    util::WinCmdLineArgs winArgs;
+    common::WinCmdLineArgs winArgs;
     std::tie(argc, argv) = winArgs.get();
 #endif
 
@@ -648,7 +649,7 @@ int GuiMain(int argc, char* argv[])
     PaymentServer::ipcParseCommandLine(argc, argv);
 #endif
 
-    QScopedPointer<const NetworkStyle> networkStyle(NetworkStyle::instantiate(Params().NetworkIDString()));
+    QScopedPointer<const NetworkStyle> networkStyle(NetworkStyle::instantiate(Params().GetChainType()));
     assert(!networkStyle.isNull());
     // Allow for separate UI settings for testnets
     // QApplication::setApplicationName(networkStyle->getAppName()); // moved to NetworkStyle::NetworkStyle
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 0ad815bd8bcf..a6aee505b904 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -11,12 +11,13 @@
 
 #include <chain.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <node/interface_ui.h>
 #include <util/std23.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 
diff --git a/src/qt/bitcoinunits.cpp b/src/qt/bitcoinunits.cpp
index 9d4bef269ead..452e48417c20 100644
--- a/src/qt/bitcoinunits.cpp
+++ b/src/qt/bitcoinunits.cpp
@@ -33,7 +33,7 @@ QList<BitcoinUnit> BitcoinUnits::availableUnits()
 
 QString BitcoinUnits::name(Unit unit)
 {
-    const bool is_mainnet{Params().NetworkIDString() == CBaseChainParams::MAIN};
+    const bool is_mainnet{Params().GetChainType() == ChainType::MAIN};
     switch (unit) {
     case Unit::DASH:  return is_mainnet ? QString("DASH") : QString("tDASH");
     case Unit::mDASH: return is_mainnet ? QString("mDASH") : QString("mtDASH");
@@ -45,7 +45,7 @@ QString BitcoinUnits::name(Unit unit)
 
 QString BitcoinUnits::description(Unit unit)
 {
-    const QString maybe_prefix{Params().NetworkIDString() == CBaseChainParams::MAIN ? "" : "Test"};
+    const QString maybe_prefix{Params().GetChainType() == ChainType::MAIN ? "" : "Test"};
     switch(unit) {
     case Unit::DASH:  return QString("%1Dash");
     case Unit::mDASH: return QString("Milli-%1Dash (1 / 1" THIN_SP_UTF8 "000)").arg(maybe_prefix);
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index 014fcde34b29..85b4b2d805a4 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -17,12 +17,13 @@
 #include <qt/peertablesortproxy.h>
 
 #include <clientversion.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <governance/object.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <net.h>
 #include <netbase.h>
-#include <util/system.h>
 #include <util/threadnames.h>
 #include <util/time.h>
 #include <validation.h>
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index edfa4f5eeb40..928d41295dfd 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -16,17 +16,19 @@
 
 #include <base58.h>
 #include <chainparams.h>
+#include <common/args.h>
 #include <interfaces/node.h>
 #include <key_io.h>
+#include <logging.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <protocol.h>
 #include <script/script.h>
 #include <script/standard.h>
+#include <util/chaintype.h>
 #include <util/exception.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 #include <util/time.h>
 
 #include <cmath>
@@ -677,12 +679,12 @@ bool LabelOutOfFocusEventFilter::eventFilter(QObject* watched, QEvent* event)
 #ifdef WIN32
 fs::path static StartupShortcutPath()
 {
-    std::string chain = gArgs.GetChainName();
-    if (chain == CBaseChainParams::MAIN)
+    ChainType chain = gArgs.GetChainType();
+    if (chain == ChainType::MAIN)
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Dash Core.lnk";
-    if (chain == CBaseChainParams::TESTNET) // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
+    if (chain == ChainType::TESTNET) // Remove this special case when testnet CBaseChainParams::DataDir() is incremented to "testnet4"
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Dash Core (testnet).lnk";
-    return GetSpecialFolderPath(CSIDL_STARTUP) / fs::u8path(strprintf("Dash Core (%s).lnk", chain));
+    return GetSpecialFolderPath(CSIDL_STARTUP) / fs::u8path(strprintf("Dash Core (%s).lnk", ChainTypeToString(chain)));
 }
 
 bool GetStartOnSystemStartup()
@@ -715,7 +717,7 @@ bool SetStartOnSystemStartup(bool fAutoStart)
             // Start client minimized
             QString strArgs = "-min";
             // Set -testnet /-regtest options
-            strArgs += QString::fromStdString(strprintf(" -chain=%s", gArgs.GetChainName()));
+            strArgs += QString::fromStdString(strprintf(" -chain=%s", gArgs.GetChainTypeString()));
 
             // Set the path to the shortcut target
             psl->SetPath(pszExePath);
@@ -760,10 +762,10 @@ fs::path static GetAutostartDir()
 
 fs::path static GetAutostartFilePath()
 {
-    std::string chain = gArgs.GetChainName();
-    if (chain == CBaseChainParams::MAIN)
+    ChainType chain = gArgs.GetChainType();
+    if (chain == ChainType::MAIN)
         return GetAutostartDir() / "dashcore.desktop";
-    return GetAutostartDir() / fs::u8path(strprintf("dashcore-%s.desktop", chain));
+    return GetAutostartDir() / fs::u8path(strprintf("dashcore-%s.desktop", ChainTypeToString(chain)));
 }
 
 bool GetStartOnSystemStartup()
@@ -803,15 +805,15 @@ bool SetStartOnSystemStartup(bool fAutoStart)
         std::ofstream optionFile{GetAutostartFilePath(), std::ios_base::out | std::ios_base::trunc};
         if (!optionFile.good())
             return false;
-        std::string chain = gArgs.GetChainName();
+        ChainType chain = gArgs.GetChainType();
         // Write a dashcore.desktop file to the autostart directory:
         optionFile << "[Desktop Entry]\n";
         optionFile << "Type=Application\n";
-        if (chain == CBaseChainParams::MAIN)
+        if (chain == ChainType::MAIN)
             optionFile << "Name=Dash Core\n";
         else
-            optionFile << strprintf("Name=Dash Core (%s)\n", chain);
-        optionFile << "Exec=" << pszExePath << strprintf(" -min -chain=%s\n", chain);
+            optionFile << strprintf("Name=Dash Core (%s)\n", ChainTypeToString(chain));
+        optionFile << "Exec=" << pszExePath << strprintf(" -min -chain=%s\n", ChainTypeToString(chain));
         optionFile << "Terminal=false\n";
         optionFile << "Hidden=false\n";
         optionFile.close();
diff --git a/src/qt/guiutil_font.cpp b/src/qt/guiutil_font.cpp
index ea1e64ca748f..8be8cc2c63a6 100644
--- a/src/qt/guiutil_font.cpp
+++ b/src/qt/guiutil_font.cpp
@@ -2,13 +2,14 @@
 // 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 <qt/guiutil.h>
 
 #include <util/helpers.h>
 
+#include <common/system.h>
 #include <tinyformat.h>
 #include <util/std23.h>
-#include <util/system.h>
 
 #include <QApplication>
 #include <QDebug>
diff --git a/src/qt/informationwidget.cpp b/src/qt/informationwidget.cpp
index 710121822b58..6d367ff95d63 100644
--- a/src/qt/informationwidget.cpp
+++ b/src/qt/informationwidget.cpp
@@ -62,7 +62,7 @@ void InformationWidget::setClientModel(ClientModel* model)
 
         ui->clientUserAgent->setText(model->formatSubVersion());
         ui->clientVersion->setText(model->formatFullVersion());
-        ui->networkName->setText(QString::fromStdString(Params().NetworkIDString()));
+        ui->networkName->setText(QString::fromStdString(Params().GetChainTypeString()));
         ui->startupTime->setText(model->formatClientStartupTime());
     }
 }
diff --git a/src/qt/intro.cpp b/src/qt/intro.cpp
index 77a98c606ca6..c012c12ad1a2 100644
--- a/src/qt/intro.cpp
+++ b/src/qt/intro.cpp
@@ -10,15 +10,16 @@
 #include <chainparams.h>
 #include <qt/intro.h>
 #include <qt/forms/ui_intro.h>
+#include <util/chaintype.h>
 #include <util/fs.h>
 
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 
+#include <common/args.h>
 #include <interfaces/node.h>
 #include <util/fs_helpers.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <QFileDialog>
@@ -224,7 +225,7 @@ bool Intro::showIfNeeded(bool& did_show_intro, int64_t& prune_MiB)
     {
         /* Use selectParams here to guarantee Params() can be used by node interface */
         try {
-            SelectParams(gArgs.GetChainName());
+            SelectParams(gArgs.GetChainType());
         } catch (const std::exception&) {
             return false;
         }
diff --git a/src/qt/mnsharesession.cpp b/src/qt/mnsharesession.cpp
index cf96952a193d..4958102c3ec4 100644
--- a/src/qt/mnsharesession.cpp
+++ b/src/qt/mnsharesession.cpp
@@ -249,7 +249,7 @@ bool shared_mn::CheckFingerprint(const UniValue& json, QString& warning)
 }
 
 MnShareSession::MnShareSession()
-    : m_network{QString::fromStdString(Params().NetworkIDString())},
+    : m_network{QString::fromStdString(Params().GetChainTypeString())},
       m_session_id{QString::fromStdString(GetRandHash().ToString())}
 {
 }
@@ -387,7 +387,7 @@ bool MnShareSession::fromJson(const UniValue& json, QString& error)
             return false;
         }
         const UniValue& network{json.find_value("network")};
-        const std::string our_network{Params().NetworkIDString()};
+        const std::string our_network{Params().GetChainTypeString()};
         if (!network.isStr() || network.get_str() != our_network) {
             error = QCoreApplication::translate("MnShareSession", "The session file is for the \"%1\" network but this "
                                                                   "node runs \"%2\". It cannot be used here.")
diff --git a/src/qt/networkstyle.cpp b/src/qt/networkstyle.cpp
index ab88f7a1c60e..3d902165c988 100644
--- a/src/qt/networkstyle.cpp
+++ b/src/qt/networkstyle.cpp
@@ -3,31 +3,32 @@
 // 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 <qt/networkstyle.h>
 
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 
 #include <chainparams.h>
+#include <common/system.h>
 #include <tinyformat.h>
-#include <util/system.h>
 
-#include <chainparamsbase.h>
+#include <util/chaintype.h>
 
 #include <QApplication>
 
 static const struct {
-    const char *networkId;
+    const ChainType networkId;
     const char *appName;
     const int iconColorHueShift;
     const int iconColorSaturationReduction;
     const char *macIconPath;
     const std::string titleAddText;
 } network_styles[] = {
-    {"main",    QAPP_APP_NAME_DEFAULT, 0,   0,  ":/icons/dash_macos_mainnet",  ""},
-    {"test",    QAPP_APP_NAME_TESTNET, 190, 20, ":/icons/dash_macos_testnet",  ""},
-    {"devnet",  QAPP_APP_NAME_DEVNET,  35,  15, ":/icons/dash_macos_devnet",   "[devnet: %s]"},
-    {"regtest", QAPP_APP_NAME_REGTEST, 160, 30, ":/icons/dash_macos_regtest",  ""},
+    {ChainType::MAIN,    QAPP_APP_NAME_DEFAULT, 0,   0,  ":/icons/dash_macos_mainnet",  ""},
+    {ChainType::TESTNET, QAPP_APP_NAME_TESTNET, 190, 20, ":/icons/dash_macos_testnet",  ""},
+    {ChainType::DEVNET,  QAPP_APP_NAME_DEVNET,  35,  15, ":/icons/dash_macos_devnet",   "[devnet: %s]"},
+    {ChainType::REGTEST, QAPP_APP_NAME_REGTEST, 160, 30, ":/icons/dash_macos_regtest",  ""},
 };
 
 void NetworkStyle::rotateColor(QColor& col, const int iconColorHueShift, const int iconColorSaturationReduction)
@@ -98,9 +99,9 @@ NetworkStyle::NetworkStyle(const QString &_appName, const int iconColorHueShift,
 #endif // Q_OS_MACOS
 }
 
-const NetworkStyle* NetworkStyle::instantiate(const std::string& networkId)
+const NetworkStyle* NetworkStyle::instantiate(const ChainType networkId)
 {
-    std::string titleAddText = networkId == CBaseChainParams::MAIN ? "" : strprintf("[%s]", networkId);
+    std::string titleAddText = networkId == ChainType::MAIN ? "" : strprintf("[%s]", ChainTypeToString(networkId));
     for (const auto& network_style : network_styles)
     {
         if (networkId == network_style.networkId)
@@ -108,7 +109,7 @@ const NetworkStyle* NetworkStyle::instantiate(const std::string& networkId)
             std::string appName = network_style.appName;
             std::string titleAddText = network_style.titleAddText;
 
-            if (networkId == CBaseChainParams::DEVNET.c_str()) {
+            if (networkId == ChainType::DEVNET) {
                 appName = strprintf(appName, gArgs.GetDevNetName());
                 titleAddText = strprintf(titleAddText, gArgs.GetDevNetName());
             }
diff --git a/src/qt/networkstyle.h b/src/qt/networkstyle.h
index f9d872e37f46..238baabc1707 100644
--- a/src/qt/networkstyle.h
+++ b/src/qt/networkstyle.h
@@ -6,6 +6,8 @@
 #ifndef BITCOIN_QT_NETWORKSTYLE_H
 #define BITCOIN_QT_NETWORKSTYLE_H
 
+#include <util/chaintype.h>
+
 #include <QIcon>
 #include <QPixmap>
 #include <QString>
@@ -17,7 +19,7 @@ class NetworkStyle
 {
 public:
     /** Get style associated with provided network id, or 0 if not known */
-    static const NetworkStyle* instantiate(const std::string& networkId);
+    static const NetworkStyle* instantiate(const ChainType networkId);
 
     const QString &getAppName() const { return appName; }
     const QIcon &getAppIcon() const { return appIcon; }
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
index a40fd0b5c657..e3cd32d8c626 100644
--- a/src/qt/optionsdialog.cpp
+++ b/src/qt/optionsdialog.cpp
@@ -16,6 +16,7 @@
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 
+#include <common/system.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
@@ -23,7 +24,6 @@
 #include <netbase.h>
 #include <txdb.h> // for -dbcache defaults
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/std23.h>
 
 #include <chrono>
diff --git a/src/qt/optionsmodel.cpp b/src/qt/optionsmodel.cpp
index fa9f1ebe8bc7..dd2f2772d231 100644
--- a/src/qt/optionsmodel.cpp
+++ b/src/qt/optionsmodel.cpp
@@ -13,13 +13,14 @@
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 
+#include <common/args.h>
+#include <common/system.h>
 #include <interfaces/node.h>
 #include <mapport.h>
 #include <net.h>
 #include <netbase.h>
-#include <txdb.h>       // for -dbcache defaults
+#include <txdb.h> // for -dbcache defaults
 #include <util/string.h>
-#include <util/system.h>
 #include <validation.h> // For DEFAULT_SCRIPTCHECK_THREADS
 
 #ifdef ENABLE_WALLET
@@ -100,7 +101,7 @@ static bool RequiresNumWorkaround(OptionsModel::OptionID option)
 }
 
 /** Call node.updateRwSetting() with Bitcoin 22.x workaround. */
-static void UpdateRwSetting(interfaces::Node& node, OptionsModel::OptionID option, const std::string& suffix, const util::SettingsValue& value)
+static void UpdateRwSetting(interfaces::Node& node, OptionsModel::OptionID option, const std::string& suffix, const common::SettingsValue& value)
 {
     if (value.isNum() && RequiresNumWorkaround(option)) {
         // Write certain old settings as strings, even though they are numbers,
@@ -117,14 +118,14 @@ static void UpdateRwSetting(interfaces::Node& node, OptionsModel::OptionID optio
 }
 
 //! Convert enabled/size values to bitcoin -prune setting.
-static util::SettingsValue PruneSetting(bool prune_enabled, int prune_size_gb)
+static common::SettingsValue PruneSetting(bool prune_enabled, int prune_size_gb)
 {
     assert(!prune_enabled || prune_size_gb >= 1); // PruneSizeGB and ParsePruneSizeGB never return less
     return prune_enabled ? PruneGBtoMiB(prune_size_gb) : 0;
 }
 
 //! Get pruning enabled value to show in GUI from bitcoin -prune setting.
-static bool PruneEnabled(const util::SettingsValue& prune_setting)
+static bool PruneEnabled(const common::SettingsValue& prune_setting)
 {
     // -prune=1 setting is manual pruning mode, so disabled for purposes of the gui
     return SettingToInt(prune_setting, 0) > 1;
@@ -132,7 +133,7 @@ static bool PruneEnabled(const util::SettingsValue& prune_setting)
 
 //! Get pruning size value to show in GUI from bitcoin -prune setting. If
 //! pruning is not enabled, just show default recommended pruning size (2GB).
-static int PruneSizeGB(const util::SettingsValue& prune_setting)
+static int PruneSizeGB(const common::SettingsValue& prune_setting)
 {
     int value = SettingToInt(prune_setting, 0);
     return value > 1 ? PruneMiBtoGB(value) : DEFAULT_PRUNE_TARGET_GB;
@@ -528,8 +529,8 @@ static QString GetDefaultProxyAddress()
 
 void OptionsModel::SetPruneTargetGB(int prune_target_gb)
 {
-    const util::SettingsValue cur_value = node().getPersistentSetting("prune");
-    const util::SettingsValue new_value = PruneSetting(prune_target_gb > 0, prune_target_gb);
+    const common::SettingsValue cur_value = node().getPersistentSetting("prune");
+    const common::SettingsValue new_value = PruneSetting(prune_target_gb > 0, prune_target_gb);
 
     // Force setting to take effect. It is still safe to change the value at
     // this point because this function is only called after the intro screen is
@@ -553,7 +554,7 @@ void OptionsModel::SetPruneTargetGB(int prune_target_gb)
 
     // Keep previous pruning size, if pruning was disabled.
     if (PruneEnabled(cur_value)) {
-        UpdateRwSetting(node(), Prune, "-prev", PruneEnabled(new_value) ? util::SettingsValue{} : cur_value);
+        UpdateRwSetting(node(), Prune, "-prev", PruneEnabled(new_value) ? common::SettingsValue{} : cur_value);
     }
 }
 
@@ -775,7 +776,7 @@ QVariant OptionsModel::getOption(OptionID option, const std::string& suffix) con
 bool OptionsModel::setOption(OptionID option, const QVariant& value, const std::string& suffix)
 {
     auto changed = [&] { return value.isValid() && value != getOption(option, suffix); };
-    auto update = [&](const util::SettingsValue& value) { return UpdateRwSetting(node(), option, suffix, value); };
+    auto update = [&](const common::SettingsValue& value) { return UpdateRwSetting(node(), option, suffix, value); };
 
     bool successful = true; /* set to false on parse error */
     QSettings settings;
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
index f69b6651b700..e2bf013115a9 100644
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -18,7 +18,9 @@
 #include <qt/walletmodel.h>
 
 #include <coinjoin/options.h>
+#include <common/args.h>
 #include <interfaces/coinjoin.h>
+#include <logging.h>
 
 #include <algorithm>
 #include <limits>
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
index 9c1edd4841cc..6315edd0cea8 100644
--- a/src/qt/paymentserver.cpp
+++ b/src/qt/paymentserver.cpp
@@ -3,6 +3,7 @@
 // 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 <qt/paymentserver.h>
 
 #include <qt/bitcoinunits.h>
@@ -11,11 +12,11 @@
 
 #include <chainparams.h>
 #include <clientversion.h>
+#include <common/system.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <node/interface_ui.h>
 #include <policy/policy.h>
-#include <util/system.h>
 
 #include <cstdlib>
 #include <memory>
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index aa19de5109a7..2963dcaeaa7a 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -23,13 +23,14 @@
 #include <qt/walletmodel.h>
 
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <interfaces/node.h>
 #include <node/connection_types.h>
 #include <rpc/client.h>
 #include <rpc/server.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/threadnames.h>
 #include <util/std23.h>
 
diff --git a/src/qt/sharedmndialogs.cpp b/src/qt/sharedmndialogs.cpp
index c2b02bcd5241..afd83188146a 100644
--- a/src/qt/sharedmndialogs.cpp
+++ b/src/qt/sharedmndialogs.cpp
@@ -655,7 +655,7 @@ UniValue SharedSigCollector::envelopeJson() const
     UniValue json(UniValue::VOBJ);
     json.pushKV("type", SIG_ENVELOPE_TYPE);
     json.pushKV("version", SIG_ENVELOPE_VERSION);
-    json.pushKV("network", Params().NetworkIDString());
+    json.pushKV("network", Params().GetChainTypeString());
     json.pushKV("kind", m_kind == Kind::Dissolve ? "dissolve" : "registrar");
     json.pushKV("proTxHash", m_protx_hash.toStdString());
     json.pushKV("tx", m_tx_hex.toStdString());
@@ -695,7 +695,7 @@ bool SharedSigCollector::importEnvelopeChecked(const UniValue& json, QString& er
     }
     QString fingerprint_warning;
     shared_mn::CheckFingerprint(json, fingerprint_warning);
-    const std::string our_network{Params().NetworkIDString()};
+    const std::string our_network{Params().GetChainTypeString()};
     const std::string their_network{json.exists("network") ? json.find_value("network").get_str() : std::string{}};
     if (their_network != our_network) {
         error = tr("This message is for the %1 network; this wallet runs on %2.")
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
index 69a7d951d979..15745e16921d 100644
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -12,13 +12,13 @@
 
 #include <chainparams.h>
 #include <clientversion.h>
+#include <common/system.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <qt/guiutil.h>
 #include <qt/networkstyle.h>
 #include <qt/walletmodel.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <cmath>
diff --git a/src/qt/test/apptests.cpp b/src/qt/test/apptests.cpp
index ea2a954e4f8c..470f4dc5e3af 100644
--- a/src/qt/test/apptests.cpp
+++ b/src/qt/test/apptests.cpp
@@ -75,7 +75,7 @@ void AppTests::appTests()
     GUIUtil::setApplicationFont();
     QVERIFY(m_app.createOptionsModel(/*resetSettings=*/true));
     QScopedPointer<const NetworkStyle> style(
-        NetworkStyle::instantiate(Params().NetworkIDString()));
+        NetworkStyle::instantiate(Params().GetChainType()));
     m_app.createWindow(style.data());
     connect(&m_app, &BitcoinApplication::windowShown, this, &AppTests::guiTests);
     expectCallback("guiTests");
diff --git a/src/qt/test/masternodemaintenancetests.cpp b/src/qt/test/masternodemaintenancetests.cpp
index b81d13c1af40..69e2adbb26a5 100644
--- a/src/qt/test/masternodemaintenancetests.cpp
+++ b/src/qt/test/masternodemaintenancetests.cpp
@@ -8,6 +8,7 @@
 
 #include <bls/bls.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <netaddress.h>
@@ -33,7 +34,6 @@
 #include <test/util/setup_common.h>
 #include <tinyformat.h>
 #include <univalue.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <wallet/context.h>
@@ -707,7 +707,7 @@ QString MakeRegistrarEnvelope(const uint256& pro_tx_hash, const COutPoint& fee_i
     UniValue json(UniValue::VOBJ);
     json.pushKV("type", "dash-shared-mn-sigs");
     json.pushKV("version", 1);
-    json.pushKV("network", Params().NetworkIDString());
+    json.pushKV("network", Params().GetChainTypeString());
     json.pushKV("kind", "registrar");
     json.pushKV("proTxHash", pro_tx_hash.ToString());
     json.pushKV("tx", EncodeHexTx(CTransaction(tx)));
@@ -748,7 +748,7 @@ QString MakeDissolveEnvelopeFor(const uint256& pro_tx_hash, const CMutableTransa
     UniValue json(UniValue::VOBJ);
     json.pushKV("type", "dash-shared-mn-sigs");
     json.pushKV("version", 1);
-    json.pushKV("network", Params().NetworkIDString());
+    json.pushKV("network", Params().GetChainTypeString());
     json.pushKV("kind", "dissolve");
     json.pushKV("proTxHash", pro_tx_hash.ToString());
     json.pushKV("tx", EncodeHexTx(CTransaction(tx)));
diff --git a/src/qt/test/masternodetestutil.cpp b/src/qt/test/masternodetestutil.cpp
index 739ada691674..45810d1f9d17 100644
--- a/src/qt/test/masternodetestutil.cpp
+++ b/src/qt/test/masternodetestutil.cpp
@@ -2,10 +2,12 @@
 // 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 <qt/test/masternodetestutil.h>
 
 #include <bls/bls.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <core_io.h>
 #include <evo/dmn_types.h>
 #include <evo/netinfo.h>
@@ -18,7 +20,6 @@
 #include <script/standard.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
-#include <util/system.h>
 #include <validation.h>
 #include <wallet/context.h>
 #include <wallet/test/util.h>
diff --git a/src/qt/test/masternodewidgettests.cpp b/src/qt/test/masternodewidgettests.cpp
index 8532984d4d3f..f612a4ff0c37 100644
--- a/src/qt/test/masternodewidgettests.cpp
+++ b/src/qt/test/masternodewidgettests.cpp
@@ -2,12 +2,14 @@
 // 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 <qt/test/masternodewidgettests.h>
 
 #include <qt/test/masternodetestutil.h>
 
 #include <bls/bls.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <evo/providertx.h>
 #include <evo/specialtx.h>
 #include <evo/types.h>
@@ -29,7 +31,6 @@
 #include <script/script.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <wallet/test/util.h>
@@ -368,7 +369,7 @@ void MasternodeWidgetTests::providerNetInfoValidation_data()
 
 void MasternodeWidgetTests::providerNetInfoValidation()
 {
-    BasicTestingSetup test{CBaseChainParams::MAIN};
+    BasicTestingSetup test{ChainType::MAIN};
     m_node.setContext(&test.m_node);
     QFETCH(int, mn_type);
     QFETCH(int, version);
diff --git a/src/qt/test/mnsharesessiontests.cpp b/src/qt/test/mnsharesessiontests.cpp
index 0a2cb9f3e5d8..53bc4571b9bf 100644
--- a/src/qt/test/mnsharesessiontests.cpp
+++ b/src/qt/test/mnsharesessiontests.cpp
@@ -108,7 +108,7 @@ MnShareSession InvitationSession()
 
 void MnShareSessionTests::validateSharesMirror()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> keys;
     MnShareSession session{ValidSession(keys)};
     QVERIFY(session.validateShares().isEmpty());
@@ -176,7 +176,7 @@ void MnShareSessionTests::validateSharesMirror()
 
 void MnShareSessionTests::envelopeRoundTrip()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> keys;
     MnShareSession session{ValidSession(keys)};
     session.shares()[0].label = "alice";
@@ -206,7 +206,7 @@ void MnShareSessionTests::envelopeRoundTrip()
 
     // Unknown stages are rejected
     json = session.toJson();
-    json.pushKV("network", QString::fromStdString(Params().NetworkIDString()).toStdString());
+    json.pushKV("network", QString::fromStdString(Params().GetChainTypeString()).toStdString());
     json.pushKV("stage", "warp");
     MnShareSession wrong_stage;
     QVERIFY(!wrong_stage.fromJson(json, error));
@@ -214,7 +214,7 @@ void MnShareSessionTests::envelopeRoundTrip()
 
 void MnShareSessionTests::envelopeFingerprint()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> keys;
     MnShareSession session{ValidSession(keys)};
     session.shares()[0].label = "alice";
@@ -291,7 +291,7 @@ void MnShareSessionTests::envelopeFingerprint()
 
 void MnShareSessionTests::draftRepliesMergeInAnyOrder()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     const MnShareSession invitation{InvitationSession()};
     const MnShareSession bob{DraftReply(invitation, 1, FakeTxid('1'))};
     const MnShareSession carol{DraftReply(invitation, 2, FakeTxid('2'))};
@@ -363,7 +363,7 @@ void MnShareSessionTests::draftRepliesMergeInAnyOrder()
 
 void MnShareSessionTests::lockedTermsAdoption()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     MnShareSession invitation{InvitationSession()};
     // The operator key is part of the invitation everybody answers, so the
     // replies carry it too
@@ -457,7 +457,7 @@ void MnShareSessionTests::lockedTermsAdoption()
 
 void MnShareSessionTests::penaltyPreviewMath()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     const std::vector<CAmount> amounts{400 * COIN, 350 * COIN, 250 * COIN};
     const CAmount penalty{5 * COIN};
     const CAmount fee{100000};
@@ -517,7 +517,7 @@ void MnShareSessionTests::earlyPeriodWording()
 
 void MnShareSessionTests::signatureVerification()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> owner_keys;
     MnShareSession session{ValidSession(owner_keys)};
     // The operator key is a first-class term; shared_register_prepare would put
@@ -602,7 +602,7 @@ void MnShareSessionTests::signatureVerification()
 
 void MnShareSessionTests::frozenEnvelopeMatchesFunding()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> owner_keys;
     MnShareSession session{ValidSession(owner_keys)};
     session.terms().coreP2PAddrs = QStringLiteral("127.0.0.1:19999");
@@ -671,7 +671,7 @@ void MnShareSessionTests::frozenEnvelopeMatchesFunding()
 
 void MnShareSessionTests::parallelFundingSignatureMerge()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> owner_keys;
     MnShareSession combined{ValidSession(owner_keys)};
     const CBLSSecretKey operator_secret{SetFreshOperatorKey(combined)};
@@ -767,7 +767,7 @@ void MnShareSessionTests::parallelFundingSignatureMerge()
 
 void MnShareSessionTests::oversizedEnvelopesAreRefused()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     std::vector<CKey> owner_keys;
     const MnShareSession session{ValidSession(owner_keys)};
     QString error;
diff --git a/src/qt/test/optiontests.cpp b/src/qt/test/optiontests.cpp
index 626b5d1079d1..616076bd2e5d 100644
--- a/src/qt/test/optiontests.cpp
+++ b/src/qt/test/optiontests.cpp
@@ -6,12 +6,12 @@
 #include <config/bitcoin-config.h>
 #endif
 
+#include <common/args.h>
 #include <init.h>
 #include <qt/bitcoin.h>
 #include <qt/guiutil.h>
 #include <qt/test/optiontests.h>
 #include <test/util/setup_common.h>
-#include <util/system.h>
 
 #include <QApplication>
 #include <QFont>
@@ -26,13 +26,13 @@
 
 OptionTests::OptionTests(interfaces::Node& node) : m_node(node)
 {
-    gArgs.LockSettings([&](util::Settings& s) { m_previous_settings = s; });
+    gArgs.LockSettings([&](common::Settings& s) { m_previous_settings = s; });
 }
 
 void OptionTests::init()
 {
     // reset args
-    gArgs.LockSettings([&](util::Settings& s) { s = m_previous_settings; });
+    gArgs.LockSettings([&](common::Settings& s) { s = m_previous_settings; });
     gArgs.ClearPathCache();
 }
 
@@ -88,14 +88,14 @@ void OptionTests::integerGetArgBug()
     // Test regression https://github.com/bitcoin/bitcoin/issues/24457. Ensure
     // that setting integer prune value doesn't cause an exception to be thrown
     // in the OptionsModel constructor
-    gArgs.LockSettings([&](util::Settings& settings) {
+    gArgs.LockSettings([&](common::Settings& settings) {
         settings.forced_settings.erase("prune");
         settings.rw_settings["prune"] = 3814;
     });
     gArgs.WriteSettingsFile();
     bilingual_str error;
     QVERIFY(OptionsModel{m_node}.Init(error));
-    gArgs.LockSettings([&](util::Settings& settings) {
+    gArgs.LockSettings([&](common::Settings& settings) {
         settings.rw_settings.erase("prune");
     });
     gArgs.WriteSettingsFile();
@@ -112,14 +112,14 @@ void OptionTests::invalidFontSetting()
              "GUIUtil::loadFonts() must succeed in AppTests::appTests() before OptionTests run.");
 
     for (const std::string setting : {"font-family", "font-scale", "font-weight-normal", "font-weight-bold"}) {
-        gArgs.LockSettings([&](util::Settings& settings) {
+        gArgs.LockSettings([&](common::Settings& settings) {
             settings.rw_settings[setting] = UniValue{UniValue::VARR};
         });
         bilingual_str error;
         QVERIFY(!OptionsModel{m_node}.Init(error));
         QCOMPARE(QString::fromStdString(error.original),
                  QString::fromStdString(strprintf("Could not read setting \"%s\", JSON value of type array is not of expected type string.", setting)));
-        gArgs.LockSettings([&](util::Settings& settings) {
+        gArgs.LockSettings([&](common::Settings& settings) {
             settings.rw_settings.erase(setting);
         });
     }
@@ -127,7 +127,7 @@ void OptionTests::invalidFontSetting()
     // With -font-family on the command line the stored weights are not used, but
     // dash-qt still reads them through gArgs later, so they must be reported too.
     for (const std::string setting : {"font-weight-normal", "font-weight-bold"}) {
-        gArgs.LockSettings([&](util::Settings& settings) {
+        gArgs.LockSettings([&](common::Settings& settings) {
             settings.command_line_options["font-family"] = {UniValue{GUIUtil::defaultFontFamily().toStdString()}};
             settings.rw_settings[setting] = UniValue{UniValue::VARR};
         });
@@ -135,7 +135,7 @@ void OptionTests::invalidFontSetting()
         QVERIFY(!OptionsModel{m_node}.Init(error));
         QCOMPARE(QString::fromStdString(error.original),
                  QString::fromStdString(strprintf("Could not read setting \"%s\", JSON value of type array is not of expected type string.", setting)));
-        gArgs.LockSettings([&](util::Settings& settings) {
+        gArgs.LockSettings([&](common::Settings& settings) {
             settings.command_line_options.erase("font-family");
             settings.rw_settings.erase(setting);
         });
@@ -147,7 +147,7 @@ void OptionTests::invalidLangSetting()
     // A "lang" value with an unexpected type in settings.json must be reported
     // through the error string like other settings instead of throwing out of
     // OptionsModel::Init.
-    gArgs.LockSettings([&](util::Settings& settings) {
+    gArgs.LockSettings([&](common::Settings& settings) {
         settings.rw_settings["lang"] = UniValue{UniValue::VOBJ};
     });
     bilingual_str error;
@@ -162,7 +162,7 @@ void OptionTests::parametersInteraction()
     // It was fixed via https://github.com/bitcoin-core/gui/pull/568.
     // With fListen=false in ~/.config/Bitcoin/Bitcoin-Qt.conf and all else left as default,
     // bitcoin-qt should set both -listen and -listenonion to false and start successfully.
-    gArgs.LockSettings([&](util::Settings& s) {
+    gArgs.LockSettings([&](common::Settings& s) {
         s.forced_settings.erase("listen");
         s.forced_settings.erase("listenonion");
     });
diff --git a/src/qt/test/optiontests.h b/src/qt/test/optiontests.h
index 2cee85ab5903..6bac879241f4 100644
--- a/src/qt/test/optiontests.h
+++ b/src/qt/test/optiontests.h
@@ -5,9 +5,9 @@
 #ifndef BITCOIN_QT_TEST_OPTIONTESTS_H
 #define BITCOIN_QT_TEST_OPTIONTESTS_H
 
+#include <common/settings.h>
 #include <qt/optionsmodel.h>
 #include <univalue.h>
-#include <util/settings.h>
 
 #include <QObject>
 
@@ -30,7 +30,7 @@ private Q_SLOTS:
 
 private:
     interfaces::Node& m_node;
-    util::Settings m_previous_settings;
+    common::Settings m_previous_settings;
 };
 
 #endif // BITCOIN_QT_TEST_OPTIONTESTS_H
diff --git a/src/qt/test/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp
index b6ee0e351307..6dc5c49fe88a 100644
--- a/src/qt/test/rpcnestedtests.cpp
+++ b/src/qt/test/rpcnestedtests.cpp
@@ -4,12 +4,12 @@
 
 #include <qt/test/rpcnestedtests.h>
 
+#include <common/system.h>
 #include <interfaces/node.h>
-#include <rpc/server.h>
 #include <qt/rpcconsole.h>
+#include <rpc/server.h>
 #include <test/util/setup_common.h>
 #include <univalue.h>
-#include <util/system.h>
 
 #include <QTest>
 
diff --git a/src/qt/test/sharedmnwalkthroughtests.cpp b/src/qt/test/sharedmnwalkthroughtests.cpp
index 6ea9e0c8bf4e..4168c493b09c 100644
--- a/src/qt/test/sharedmnwalkthroughtests.cpp
+++ b/src/qt/test/sharedmnwalkthroughtests.cpp
@@ -9,6 +9,7 @@
 #include <bls/bls.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <core_io.h>
 #include <evo/deterministicmns.h>
@@ -35,7 +36,6 @@
 #include <test/util/setup_common.h>
 #include <univalue.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
diff --git a/src/qt/test/sharedmnwidgettests.cpp b/src/qt/test/sharedmnwidgettests.cpp
index c3aae53c4d78..2f92c9013f05 100644
--- a/src/qt/test/sharedmnwidgettests.cpp
+++ b/src/qt/test/sharedmnwidgettests.cpp
@@ -80,7 +80,7 @@ QString TransactionHex(uint16_t type)
 
 void SharedMnWidgetTests::importDetection()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
 
     // A session envelope is recognised from its own type field
     const MnShareSession session{TwoShareSession()};
@@ -92,7 +92,7 @@ void SharedMnWidgetTests::importDetection()
     UniValue sigs(UniValue::VOBJ);
     sigs.pushKV("type", "dash-shared-mn-sigs");
     sigs.pushKV("version", 1);
-    sigs.pushKV("network", Params().NetworkIDString());
+    sigs.pushKV("network", Params().GetChainTypeString());
     sigs.pushKV("kind", "dissolve");
     sigs.pushKV("proTxHash", std::string(64, 'a'));
     shared_mn::AppendFingerprint(sigs);
@@ -158,7 +158,7 @@ void SharedMnWidgetTests::statusBoardCells()
 
 void SharedMnWidgetTests::termSheetWarnsWhenWePayMoreThanOurShare()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     const MnShareSession session{TwoShareSession()};
     const CAmount share{session.shares()[1].amount};
     const auto sheet = [&](int you, std::optional<SharedMnOwnFunding> funding) {
@@ -192,7 +192,7 @@ void SharedMnWidgetTests::termSheetWarnsWhenWePayMoreThanOurShare()
 
 void SharedMnWidgetTests::termSheetEscapesUntrustedText()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     const MnShareSession session{TwoShareSession()};
     const QString html{SharedMnTermSheetHtml(session, /*you_share_index=*/1, BitcoinUnits::Unit::DASH)};
 
diff --git a/src/qt/test/sharedmnwizardtests.cpp b/src/qt/test/sharedmnwizardtests.cpp
index 50ae27f77f61..8d417ac0bf16 100644
--- a/src/qt/test/sharedmnwizardtests.cpp
+++ b/src/qt/test/sharedmnwizardtests.cpp
@@ -18,6 +18,7 @@
 
 #include <bls/bls.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <core_io.h>
 #include <evo/deterministicmns.h>
@@ -37,7 +38,6 @@
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <wallet/context.h>
@@ -133,7 +133,7 @@ void AnswerMessageBox(const QString& answer, QString& title)
 
 void SharedMnWizardTests::coordinatorPageOrder()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
 
@@ -166,7 +166,7 @@ void SharedMnWizardTests::coordinatorPageOrder()
 
 void SharedMnWizardTests::participantPagesAndRoleInference()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
 
@@ -206,7 +206,7 @@ void SharedMnWizardTests::participantPagesAndRoleInference()
 
 void SharedMnWizardTests::participantCannotChooseATakenShare()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -293,7 +293,7 @@ void SharedMnWizardTests::participantCannotChooseATakenShare()
 
 void SharedMnWizardTests::coordinatorResumesSavedSession()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -402,7 +402,7 @@ void SharedMnWizardTests::coordinatorResumesSavedSession()
 
 void SharedMnWizardTests::coordinatorResumesFullySignedSession()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -457,7 +457,7 @@ void SharedMnWizardTests::coordinatorResumesFullySignedSession()
 
 void SharedMnWizardTests::signedSessionReservation()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -775,7 +775,7 @@ void SharedMnWizardTests::signedSessionReservation()
 
 void SharedMnWizardTests::unauthorisedSignedInputsAreDetected()
 {
-    BasicTestingSetup setup{CBaseChainParams::REGTEST};
+    BasicTestingSetup setup{ChainType::REGTEST};
     const auto hex = [](const CMutableTransaction& tx) {
         return QString::fromStdString(EncodeHexTx(CTransaction(tx)));
     };
@@ -829,7 +829,7 @@ void SharedMnWizardTests::unauthorisedSignedInputsAreDetected()
 
 void SharedMnWizardTests::refusesToSignCoinsOutsideOwnContribution()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -921,7 +921,7 @@ void SharedMnWizardTests::refusesToSignCoinsOutsideOwnContribution()
 
 void SharedMnWizardTests::refusesToSignShortChangedOwnContribution()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -1082,7 +1082,7 @@ void SharedMnWizardTests::refusesToSignShortChangedOwnContribution()
 
 void SharedMnWizardTests::newerRevisionKeepsOwnShare()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -1465,7 +1465,7 @@ void SharedMnWizardTests::newerRevisionKeepsOwnShare()
 
 void SharedMnWizardTests::savingWaitsForTheOperatorKeyBackup()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -1520,7 +1520,7 @@ void SharedMnWizardTests::savingWaitsForTheOperatorKeyBackup()
 
 void SharedMnWizardTests::coordinatorCanRetryOwnApproval()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -1581,7 +1581,7 @@ void SharedMnWizardTests::coordinatorCanRetryOwnApproval()
 
 void SharedMnWizardTests::participantsPageGating()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
     dialog.m_role = SharedMnCreateDialog::Role::Coordinator;
@@ -1652,7 +1652,7 @@ void SharedMnWizardTests::serviceAddressInUseIsRefused()
 {
     // DIP3 is active at the tip, so the tip's masternode list is what the
     // network checks a registration's service address against
-    TestChainSetup test{107, CBaseChainParams::REGTEST, {"-dip3params=109:500"}};
+    TestChainSetup test{107, ChainType::REGTEST, {"-dip3params=109:500"}};
     test.mineBlocks(2);
     m_node.setContext(&test.m_node);
     const CBlockIndex* const tip{WITH_LOCK(::cs_main, return test.m_node.chainman->ActiveChain().Tip())};
@@ -1714,7 +1714,7 @@ void SharedMnWizardTests::serviceAddressInUseIsRefused()
 
 void SharedMnWizardTests::reusedRefundAddressIsRefusedBeforeReserving()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     WalletContext& context{*m_node.walletLoader().context()};
 
@@ -1787,7 +1787,7 @@ void SharedMnWizardTests::reusedRefundAddressIsRefusedBeforeReserving()
 
 void SharedMnWizardTests::statusBoardAbsorbsRepliesInAnyOrder()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
 
@@ -1850,7 +1850,7 @@ void SharedMnWizardTests::statusBoardAbsorbsRepliesInAnyOrder()
 
 void SharedMnWizardTests::pastedMessageRouting()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
 
@@ -1911,7 +1911,7 @@ void SharedMnWizardTests::pastedMessageRouting()
 
 void SharedMnWizardTests::copyPutsFingerprintedEnvelopeOnClipboard()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
     dialog.m_session = DraftReply(InvitationSession(), 0, FakeTxid('1'));
@@ -1941,7 +1941,7 @@ void SharedMnWizardTests::copyPutsFingerprintedEnvelopeOnClipboard()
 
 void SharedMnWizardTests::unlockingDiscardsApprovals()
 {
-    TestingSetup test{CBaseChainParams::REGTEST};
+    TestingSetup test{ChainType::REGTEST};
     m_node.setContext(&test.m_node);
     SharedMnCreateDialog dialog(m_node, /*wallet_model=*/nullptr, /*parent=*/nullptr);
 
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index 92251e17a5a2..3d91e02bd925 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -17,6 +17,7 @@
 #include <qt/test/uritests.h>
 #include <qt/test/trafficgraphdatatests.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 
 #ifdef ENABLE_WALLET
 #include <qt/test/addressbooktests.h>
@@ -68,7 +69,7 @@ int main(int argc, char* argv[])
     //
     // All tests must use their own testing setup (if needed).
     fs::create_directories([] {
-        BasicTestingSetup dummy{CBaseChainParams::REGTEST};
+        BasicTestingSetup dummy{ChainType::REGTEST};
         return gArgs.GetDataDirNet() / "blocks";
     }());
 
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index bb65763fa3bc..dc6b7a0153f3 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -7,6 +7,7 @@
 #include <qt/test/util.h>
 
 #include <chainparams.h>
+#include <common/system.h>
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <qt/bitcoinamountfield.h>
@@ -26,7 +27,6 @@
 #include <test/util/setup_common.h>
 #include <txmempool.h>
 #include <util/error.h>
-#include <util/system.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <wallet/coincontrol.h>
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 4e83f6bf2f67..9901478c8e33 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -10,6 +10,7 @@
 #include <qt/paymentserver.h>
 #include <qt/transactionrecord.h>
 
+#include <common/system.h>
 #include <consensus/consensus.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
@@ -17,7 +18,6 @@
 #include <logging.h>
 #include <script/script.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <validation.h>
 #include <wallet/types.h>
 
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index 049bf72a22dc..e4d219f3502b 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -12,10 +12,10 @@
 #include <qt/transactionrecord.h>
 #include <qt/walletmodel.h>
 
+#include <common/system.h>
 #include <core_io.h>
 #include <interfaces/handler.h>
 #include <uint256.h>
-#include <util/system.h>
 
 #include <algorithm>
 #include <functional>
diff --git a/src/qt/utilitydialog.cpp b/src/qt/utilitydialog.cpp
index 3aaebe18d49d..9214aa7ff40e 100644
--- a/src/qt/utilitydialog.cpp
+++ b/src/qt/utilitydialog.cpp
@@ -14,10 +14,11 @@
 #include <qt/guiutil.h>
 
 #include <clientversion.h>
+#include <common/args.h>
 #include <init.h>
-#include <util/system.h>
 #include <util/strencodings.h>
 
+#include <common/system.h>
 #include <cstdio>
 
 #include <QCloseEvent>
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index f8c77be578eb..a0dd3a1424bb 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -3,6 +3,7 @@
 // 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 <qt/walletmodel.h>
 
 #include <qt/addresstablemodel.h>
@@ -21,7 +22,6 @@
 #include <node/interface_ui.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
-#include <util/system.h> // for GetBoolArg
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h> // for CRecipient
diff --git a/src/rest.cpp b/src/rest.cpp
index ac06fd635ff3..97041af00e85 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -31,6 +31,7 @@
 #include <streams.h>
 #include <sync.h>
 #include <txmempool.h>
+#include <util/any.h>
 #include <util/check.h>
 #include <util/strencodings.h>
 #include <validation.h>
@@ -42,7 +43,6 @@
 
 using node::GetTransaction;
 using node::NodeContext;
-using node::ReadBlockFromDisk;
 
 static const size_t MAX_GETUTXOS_OUTPOINTS = 15; //allow a max of 15 outpoints to be queried at once
 static constexpr unsigned int MAX_REST_HEADERS_RESULTS = 2000;
@@ -340,7 +340,7 @@ static bool rest_block(const CoreContext& context,
             return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not available (pruned data)");
     }
 
-    if (!ReadBlockFromDisk(block, pblockindex, chainman.GetParams().GetConsensus())) {
+    if (!chainman.m_blockman.ReadBlockFromDisk(block, *pblockindex)) {
         return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
     }
 
@@ -760,7 +760,7 @@ static bool rest_tx(const CoreContext& context, HTTPRequest* req, const std::str
     const NodeContext* const node = GetNodeContext(context, req);
     if (!node) return false;
     uint256 hashBlock = uint256();
-    const CTransactionRef tx = GetTransaction(/*block_index=*/nullptr, node->mempool.get(), hash, Params().GetConsensus(), hashBlock);
+    const CTransactionRef tx = GetTransaction(/*block_index=*/nullptr, node->mempool.get(), hash, hashBlock, node->chainman->m_blockman);
     if (!tx) {
         return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
     }
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index d92c87444550..9eeae575a609 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -10,6 +10,7 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
+#include <common/args.h>
 #include <consensus/amount.h>
 #include <core_io.h>
 #include <consensus/params.h>
@@ -43,7 +44,6 @@
 #include <util/check.h>
 #include <util/fs.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -72,9 +72,7 @@ using kernel::CoinStatsHashType;
 
 using node::BlockManager;
 using node::NodeContext;
-using node::ReadBlockFromDisk;
 using node::SnapshotMetadata;
-using node::UndoReadFromDisk;
 
 struct CUpdatedBlock
 {
@@ -183,7 +181,7 @@ UniValue blockToJSON(BlockManager& blockman, const CBlock& block, const CBlockIn
         case TxVerbosity::SHOW_DETAILS_AND_PREVOUT:
             CBlockUndo blockUndo;
             const bool is_not_pruned{WITH_LOCK(::cs_main, return !blockman.IsBlockPruned(blockindex))};
-            const bool have_undo{is_not_pruned && UndoReadFromDisk(blockUndo, blockindex)};
+            const bool have_undo{is_not_pruned && blockman.UndoReadFromDisk(blockUndo, *blockindex)};
 
             for (size_t i = 0; i < block.vtx.size(); ++i) {
                 const CTransactionRef& tx = block.vtx.at(i);
@@ -795,7 +793,7 @@ static CBlock GetBlockChecked(BlockManager& blockman, const CBlockIndex* pblocki
         }
     }
 
-    if (!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus())) {
+    if (!blockman.ReadBlockFromDisk(block, *pblockindex)) {
         // Block not found on disk. This could be because we have the block
         // header in our index but not yet have the block or did not accept the
         // block. Or if the block was pruned right after we released the lock above.
@@ -819,7 +817,7 @@ static CBlockUndo GetUndoChecked(BlockManager& blockman, const CBlockIndex* pblo
         }
     }
 
-    if (!UndoReadFromDisk(blockUndo, pblockindex)) {
+    if (!blockman.UndoReadFromDisk(blockUndo, *pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Can't read undo data from disk");
     }
 
@@ -908,7 +906,7 @@ static RPCHelpMan getmerkleblocks()
             break;
         }
 
-        if (!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus())) {
+        if (!chainman.m_blockman.ReadBlockFromDisk(block, *pblockindex)) {
             // this shouldn't happen, we already checked pruning case earlier
             throw JSONRPCError(RPC_MISC_ERROR, "Block not found on disk");
         }
@@ -1438,7 +1436,7 @@ static RPCHelpMan verifychain()
     LOCK(cs_main);
 
     Chainstate& active_chainstate = chainman.ActiveChainstate();
-    return CVerifyDB().VerifyDB(
+    return CVerifyDB(chainman.GetNotifications()).VerifyDB(
                active_chainstate, chainman.GetParams().GetConsensus(), active_chainstate.CoinsTip(), *CHECK_NONFATAL(node.evodb), check_level, check_depth) == VerifyDBResult::SUCCESS;
 },
     };
@@ -1599,7 +1597,7 @@ RPCHelpMan getblockchaininfo()
     if (args.IsArgSet("-devnet")) {
         obj.pushKV("chain", args.GetDevNetName());
     } else {
-        obj.pushKV("chain", chainman.GetParams().NetworkIDString());
+        obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
     }
     obj.pushKV("blocks", height);
     obj.pushKV("headers", chainman.m_best_header ? chainman.m_best_header->nHeight : -1);
@@ -1807,7 +1805,7 @@ static RPCHelpMan getcreditpoolinfo()
     const CCreditPool pool{cpoolman.GetCreditPool(pindex)};
     // The same read the consensus rule makes for the window start
     const CAmount window_start_balance{
-        pindex_window_start ? CCreditPoolManager::GetBalanceAt(pindex_window_start, chainman.GetConsensus()) : CAmount{0}};
+        pindex_window_start ? CCreditPoolManager::GetBalanceAt(pindex_window_start, chainman.m_blockman, chainman.GetConsensus()) : CAmount{0}};
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("height", pindex->nHeight);
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 7fe8d09cb306..39a5f85f0129 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -4,9 +4,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+
+#include <common/args.h>
 #include <rpc/client.h>
 #include <tinyformat.h>
-#include <util/system.h>
 
 #include <map>
 #include <string>
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index c72ff05396af..f272ee9eba61 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -2,6 +2,10 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <active/context.h>
+#include <coinjoin/server.h>
+#include <coinjoin/walletman.h>
+#include <common/args.h>
 #include <node/context.h>
 #include <rpc/json_help.h>
 #include <rpc/server.h>
@@ -12,10 +16,6 @@
 #include <wallet/rpc/util.h>
 #include <walletinitinterface.h>
 
-#include <active/context.h>
-#include <coinjoin/server.h>
-#include <coinjoin/walletman.h>
-
 #ifdef ENABLE_WALLET
 #include <coinjoin/options.h>
 #include <interfaces/coinjoin.h>
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 1d9fb83bda6e..a256bda18ffb 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -4,6 +4,7 @@
 
 #include <bls/bls.h>
 #include <chainparams.h>
+#include <common/args.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <deploymentstatus.h>
@@ -1605,7 +1606,7 @@ static UniValue BuildDMNListEntry(const CWallet* const pwallet, const CDetermini
             confirmations -= WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()) - pindex->nHeight;
         } else {
             uint256 minedBlockHash;
-            collateralTx = GetTransaction(/* pindex */ nullptr, /* mempool */ nullptr, dmn.collateralOutpoint.hash, Params().GetConsensus(), minedBlockHash);
+            collateralTx = GetTransaction(/* pindex */ nullptr, /* mempool */ nullptr, dmn.collateralOutpoint.hash, minedBlockHash, chainman.m_blockman);
             const CBlockIndex* const pindexMined = WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(minedBlockHash));
             CHECK_NONFATAL(pindexMined != nullptr);
             CHECK_NONFATAL(pindex->GetAncestor(pindexMined->nHeight) == pindexMined);
@@ -2066,7 +2067,7 @@ static UniValue evodb_verify_or_repair_impl(const JSONRPCRequest& request, bool
     };
 
     // Call the dmnman method to do the work
-    auto recalc_result = dmnman.RecalculateAndRepairDiffs(start_index, stop_index, build_list_func, repair);
+    auto recalc_result = dmnman.RecalculateAndRepairDiffs(chainman.m_blockman, start_index, stop_index, build_list_func, repair);
 
     // Convert result to UniValue
     UniValue result(UniValue::VOBJ);
diff --git a/src/rpc/external_signer.cpp b/src/rpc/external_signer.cpp
index 29d2ee645de0..db673748eada 100644
--- a/src/rpc/external_signer.cpp
+++ b/src/rpc/external_signer.cpp
@@ -8,10 +8,12 @@
 
 #include <chainparamsbase.h>
 
+#include <common/args.h>
+#include <common/system.h>
 #include <external_signer.h>
+#include <rpc/protocol.h>
 #include <rpc/server.h>
 #include <util/strencodings.h>
-#include <rpc/protocol.h>
 
 #include <string>
 #include <vector>
@@ -45,7 +47,7 @@ static RPCHelpMan enumeratesigners()
         {
             const std::string command = gArgs.GetArg("-signer", "");
             if (command == "") throw JSONRPCError(RPC_MISC_ERROR, "Error: restart dashd with -signer=<cmd>");
-            const std::string chain = gArgs.GetChainName();
+            const std::string chain = gArgs.GetChainTypeString();
             UniValue signers_res = UniValue::VARR;
             try {
                 std::vector<ExternalSigner> signers;
diff --git a/src/rpc/fees.cpp b/src/rpc/fees.cpp
index a1c7beee9161..b0b0d78f5217 100644
--- a/src/rpc/fees.cpp
+++ b/src/rpc/fees.cpp
@@ -3,6 +3,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <core_io.h>
 #include <node/context.h>
 #include <policy/feerate.h>
@@ -16,7 +17,6 @@
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/fees.h>
-#include <util/system.h>
 
 #include <algorithm>
 #include <array>
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 4d9192d38f23..95c591e1cf78 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -35,7 +35,6 @@
 
 using node::GetTransaction;
 using node::NodeContext;
-using node::ReadBlockFromDisk;
 #ifdef ENABLE_WALLET
 using wallet::CCoinControl;
 using wallet::CoinType;
@@ -418,7 +417,7 @@ static RPCHelpMan masternode_payments()
     // Payees are selected from the previous block's list, so the genesis block has none
     while (vecPayments.size() < uint64_t(std::abs(nCount)) && pindex != nullptr && pindex->pprev != nullptr) {
         CBlock block;
-        if (!ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+        if (!chainman.m_blockman.ReadBlockFromDisk(block, *pindex)) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
         }
 
@@ -440,7 +439,7 @@ static RPCHelpMan masternode_payments()
             CAmount nValueIn{0};
             for (const auto& txin : tx->vin) {
                 uint256 blockHashTmp;
-                CTransactionRef txPrev = GetTransaction(/* block_index */ nullptr, &mempool, txin.prevout.hash, Params().GetConsensus(), blockHashTmp);
+                CTransactionRef txPrev = GetTransaction(/* block_index */ nullptr, &mempool, txin.prevout.hash, blockHashTmp, chainman.m_blockman);
                 if (!txPrev) {
                     throw JSONRPCError(RPC_MISC_ERROR, "Unable to calculate block fees: previous transaction not "
                                                        "found. Use -txindex to enable historical transaction queries");
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 536dde24d37b..d0a471d58dad 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -3,11 +3,13 @@
 // 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 <rpc/blockchain.h>
 
 #include <kernel/mempool_persist.h>
 
 #include <chainparams.h>
+#include <common/system.h>
 #include <core_io.h>
 #include <instantsend/instantsend.h>
 #include <kernel/mempool_entry.h>
@@ -24,7 +26,6 @@
 #include <util/helpers.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
@@ -804,7 +805,7 @@ static RPCHelpMan submitpackage()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
         {
-            if (!Params().IsMockableChain()) {
+            if (Params().GetChainType() != ChainType::REGTEST) {
                 throw std::runtime_error("submitpackage is for regression testing (-regtest mode) only");
             }
             const UniValue raw_transactions = request.params[0].get_array();
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 2f368c64e217..acd267b1eb5c 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -10,6 +10,7 @@
 
 #include <chain.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
@@ -43,7 +44,6 @@
 #include <util/check.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -487,7 +487,7 @@ static RPCHelpMan getmininginfo()
     obj.pushKV("difficulty",       (double)GetDifficulty(active_chain.Tip()));
     obj.pushKV("networkhashps",    getnetworkhashps().HandleRequest(request));
     obj.pushKV("pooledtx",         (uint64_t)mempool.size());
-    obj.pushKV("chain", chainman.GetParams().NetworkIDString());
+    obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
     obj.pushKV("warnings",         GetWarnings(false).original);
     return obj;
 },
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 5485d8172de9..0c476123b7bb 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -24,6 +24,7 @@
 #include <rpc/util.h>
 #include <sync.h>
 #include <timedata.h>
+#include <util/chaintype.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
@@ -398,7 +399,7 @@ static RPCHelpMan addconnection()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
-    if (Params().NetworkIDString() != CBaseChainParams::REGTEST) {
+    if (Params().GetChainType() != ChainType::REGTEST) {
         throw std::runtime_error("addconnection is for regression testing (-regtest mode) only.");
     }
 
@@ -1108,7 +1109,7 @@ static RPCHelpMan setmnthreadactive()
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
 
-    if (Params().NetworkIDString() != CBaseChainParams::REGTEST) {
+    if (Params().GetChainType() != ChainType::REGTEST) {
         throw std::runtime_error("setmnthreadactive is for regression testing (-regtest mode) only.");
     }
 
diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp
index 3d5c71c346da..0ef365ede78c 100644
--- a/src/rpc/node.cpp
+++ b/src/rpc/node.cpp
@@ -36,8 +36,8 @@
 #include <scheduler.h>
 #include <txmempool.h>
 #include <univalue.h>
+#include <util/any.h>
 #include <util/check.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <masternode/sync.h>
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index a1bc1ca7da88..3d211138d3ea 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -1313,7 +1313,7 @@ static RPCHelpMan verifyislock()
     {
         LOCK(cs_main);
         uint256 hash_block;
-        CTransactionRef tx = GetTransaction(/* block_index */ nullptr,  /* mempool */ nullptr, txid, Params().GetConsensus(), hash_block);
+        CTransactionRef tx = GetTransaction(/* block_index */ nullptr,  /* mempool */ nullptr, txid, hash_block, chainman.m_blockman);
         if (tx && !hash_block.IsNull()) {
             pindexMined = chainman.m_blockman.LookupBlockIndex(hash_block);
         }
@@ -1449,7 +1449,7 @@ static RPCHelpMan getchainlockbyheight()
             CBlockIndex* tip = WITH_LOCK(cs_main, return chainman.ActiveChain().Tip());
             CHECK_NONFATAL(tip != nullptr);
             try {
-                chainlock::CoinbaseChainLockReader reader(tip);
+                chainlock::CoinbaseChainLockReader reader(tip, chainman.m_blockman);
                 const auto entry = reader.Find(height, height);
                 if (!entry) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Chainlock not found for height");
                 {
@@ -1516,7 +1516,7 @@ static RPCHelpMan getquorumproofchain()
                     throw JSONRPCError(RPC_INVALID_PARAMETER, "Checkpoint is not on the active chain");
             }
             try {
-                chainlock::CoinbaseChainLockReader reader(tip);
+                chainlock::CoinbaseChainLockReader reader(tip, chainman.m_blockman);
                 const int64_t start = std::max<int64_t>(minimum, int64_t(checkpoint->nHeight) + 1);
                 if (start > tip->nHeight) throw std::runtime_error("No archived certificate within search budget");
                 const int maximum = int(std::min<int64_t>(tip->nHeight, start + int64_t(llmq::MAX_PROOF_HEADERS)));
@@ -1563,7 +1563,7 @@ static RPCHelpMan getquorumproofchain()
                 if (!proof) throw std::runtime_error("No bridge to snapshot within search budget");
                 // Build() already verified the proof and matched the result against the
                 // chain; the target is exactly the state at the target block.
-                const auto state = llmq::QuorumProofBuilder::StateAt(target);
+                const auto state = llmq::QuorumProofBuilder::StateAt(chainman.m_blockman, target);
                 std::vector<llmq::ProofProjection> records;
                 if (!quorumText.empty()) {
                     const auto hash = uint256S(quorumText);
@@ -1585,7 +1585,7 @@ static RPCHelpMan getquorumproofchain()
                     if (!found) throw std::runtime_error("Requested quorum is not in the target root");
                 }
                 if (nodeCount > 0) {
-                    const auto [sml, leaves] = llmq::MasternodeLeavesAt(*CHECK_NONFATAL(node.dmnman), target);
+                    const auto [sml, leaves] = llmq::MasternodeLeavesAt(*CHECK_NONFATAL(node.dmnman), chainman.m_blockman, target);
                     int included = 0;
                     for (size_t i = 0; i < sml->mnList.size() && included < nodeCount; ++i) {
                         const auto& entry = *sml->mnList[i];
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index ca5f3d392cd8..bb81d96f7826 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -69,8 +69,6 @@ using node::AnalyzePSBT;
 using node::GetTransaction;
 using node::NodeContext;
 using node::PSBTAnalysis;
-using node::ReadBlockFromDisk;
-using node::UndoReadFromDisk;
 
 void TxToJSON(const CTransaction& tx, const uint256 hashBlock, const  CTxMemPool& mempool, const Chainstate& active_chainstate, const chainlock::Chainlocks& chainlocks, const llmq::CInstantSendManager& isman, const SpentIndex* spent_index, UniValue& entry, const CTxUndo* txundo = nullptr, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS)
 {
@@ -446,7 +444,7 @@ static RPCHelpMan getrawtransaction()
     }
 
     uint256 hash_block;
-    const CTransactionRef tx = GetTransaction(blockindex, node.mempool.get(), hash, chainman.GetConsensus(), hash_block);
+    const CTransactionRef tx = GetTransaction(blockindex, node.mempool.get(), hash, hash_block, chainman.m_blockman);
     if (!tx) {
         std::string errmsg;
         if (blockindex) {
@@ -493,7 +491,7 @@ static RPCHelpMan getrawtransaction()
     const bool is_block_pruned{WITH_LOCK(cs_main, return chainman.m_blockman.IsBlockPruned(blockindex))};
 
     if (tx->IsCoinBase() || is_block_pruned ||
-        !(UndoReadFromDisk(blockUndo, blockindex) && ReadBlockFromDisk(block, blockindex, Params().GetConsensus()))) {
+        !(chainman.m_blockman.UndoReadFromDisk(blockUndo, *blockindex) && chainman.m_blockman.ReadBlockFromDisk(block, *blockindex))) {
         TxToJSON(*tx, hash_block, mempool, chainman.ActiveChainstate(), *node.chainlocks, isman, node.spent_index.get(), result);
         return result;
     }
@@ -595,7 +593,7 @@ static RPCHelpMan getrawtransactionmulti() {
             const uint256 txid = ParseHashV(txid_str, "transaction id");
 
             uint256 hash_block;
-            const CTransactionRef tx = GetTransaction(blockindex, &mempool, txid, Params().GetConsensus(), hash_block);
+            const CTransactionRef tx = GetTransaction(blockindex, &mempool, txid, hash_block, chainman.m_blockman);
             if (!tx) {
                 result.pushKV(txid_str, "None");
             } else if (verbosity > 0) {
@@ -750,7 +748,7 @@ static RPCHelpMan gettxchainlocks()
         int height{-1};
         bool chainLock{false};
 
-        const auto tx_ref = GetTransaction(nullptr, node.mempool.get(), txid, Params().GetConsensus(), hash_block);
+        const auto tx_ref = GetTransaction(nullptr, node.mempool.get(), txid, hash_block, chainman.m_blockman);
 
         if (tx_ref == nullptr) {
             result.pushKV("height", -1);
@@ -856,7 +854,7 @@ static RPCHelpMan getassetunlockstatuses()
                 return pTipBlockIndex->GetAncestor(best_clsig.getHeight());
             }
             // If no CL info is available, try to use CbTx CL information
-            if (const auto cbtx_best_cl = GetNonNullCoinbaseChainlock(pTipBlockIndex)) {
+            if (const auto cbtx_best_cl = GetNonNullCoinbaseChainlock(chainman.m_blockman, pTipBlockIndex)) {
                 return pTipBlockIndex->GetAncestor(pTipBlockIndex->nHeight - cbtx_best_cl->second - 1);
             }
             // no CL info, no CbTx CL
diff --git a/src/rpc/request.cpp b/src/rpc/request.cpp
index 847486894629..219879474362 100644
--- a/src/rpc/request.cpp
+++ b/src/rpc/request.cpp
@@ -8,11 +8,12 @@
 
 #include <util/fs.h>
 
+#include <common/args.h>
+#include <logging.h>
 #include <random.h>
 #include <rpc/protocol.h>
 #include <util/fs_helpers.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 
 #include <fstream>
 #include <stdexcept>
@@ -90,7 +91,7 @@ bool GenerateAuthCookie(std::string *cookie_out)
     std::string cookie = COOKIEAUTH_USER + ":" + HexStr(rand_pwd);
 
     /** the umask determines what permissions are used to create this file -
-     * these are set to 0077 in util/system.cpp.
+     * these are set to 0077 in common/system.cpp.
      */
     std::ofstream file;
     fs::path filepath_tmp = GetAuthCookieFile(true);
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 5dfe27db2756..8500872fdbc5 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -10,12 +10,14 @@
 
 #include <rpc/server.h>
 
+#include <common/args.h>
+#include <common/system.h>
+#include <logging.h>
 #include <rpc/util.h>
 #include <shutdown.h>
 #include <sync.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/time.h>
 
 #include <boost/signals2/signal.hpp>
diff --git a/src/rpc/server_util.cpp b/src/rpc/server_util.cpp
index 1cee5f109dc6..64e1c2e9044c 100644
--- a/src/rpc/server_util.cpp
+++ b/src/rpc/server_util.cpp
@@ -2,6 +2,7 @@
 // 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 <rpc/server_util.h>
 
 #include <banman.h>
@@ -11,7 +12,7 @@
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 #include <txmempool.h>
-#include <util/system.h>
+#include <util/any.h>
 #include <validation.h>
 
 #ifdef ENABLE_WALLET
diff --git a/src/rpc/txoutproof.cpp b/src/rpc/txoutproof.cpp
index af7281ce6f1c..48eff50b5a61 100644
--- a/src/rpc/txoutproof.cpp
+++ b/src/rpc/txoutproof.cpp
@@ -18,7 +18,6 @@
 #include <validation.h>
 
 using node::GetTransaction;
-using node::ReadBlockFromDisk;
 
 static RPCHelpMan gettxoutproof()
 {
@@ -89,7 +88,7 @@ static RPCHelpMan gettxoutproof()
             }
 
             if (pblockindex == nullptr) {
-                const CTransactionRef tx = GetTransaction(/*block_index=*/nullptr, /*mempool=*/nullptr, *setTxids.begin(), chainman.GetConsensus(), hashBlock);
+                const CTransactionRef tx = GetTransaction(/*block_index=*/nullptr, /*mempool=*/nullptr, *setTxids.begin(), hashBlock, chainman.m_blockman);
                 if (!tx || hashBlock.IsNull()) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not yet in block");
                 }
@@ -100,7 +99,7 @@ static RPCHelpMan gettxoutproof()
             }
 
             CBlock block;
-            if (!ReadBlockFromDisk(block, pblockindex, chainman.GetConsensus())) {
+            if (!chainman.m_blockman.ReadBlockFromDisk(block, *pblockindex)) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
             }
 
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 8bb5e2ff4967..d76f94cab6c1 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -7,6 +7,7 @@
 #include <config/bitcoin-config.h>
 #endif
 #include <clientversion.h>
+#include <common/args.h>
 #include <core_io.h>
 #include <consensus/amount.h>
 #include <script/interpreter.h>
@@ -22,7 +23,6 @@
 #include <util/std23.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 const std::string UNIX_EPOCH_TIME = "UNIX epoch time";
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 292b009278e0..95f87d4d13f6 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -9,11 +9,12 @@
 #include <script/script.h>
 #include <script/standard.h>
 
+#include <common/args.h>
+#include <common/system.h>
 #include <span.h>
 #include <util/bip32.h>
 #include <util/spanparsing.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/vector.h>
 
 #include <memory>
diff --git a/src/script/sigcache.cpp b/src/script/sigcache.cpp
index e1719ac34e4d..90447bc61fea 100644
--- a/src/script/sigcache.cpp
+++ b/src/script/sigcache.cpp
@@ -5,10 +5,11 @@
 
 #include <script/sigcache.h>
 
+#include <common/system.h>
+#include <logging.h>
 #include <pubkey.h>
 #include <random.h>
 #include <uint256.h>
-#include <util/system.h>
 
 #include <cuckoocache.h>
 
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index 41a2a7508b35..3cf94b297af8 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -4,15 +4,16 @@
 // 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 <stats/client.h>
 
+#include <common/system.h>
 #include <logging.h>
 #include <random.h>
 #include <stats/rawsender.h>
 #include <sync.h>
 #include <util/check.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <algorithm>
diff --git a/src/test/allocator_tests.cpp b/src/test/allocator_tests.cpp
index 53978764e1f0..91ffbc08abc1 100644
--- a/src/test/allocator_tests.cpp
+++ b/src/test/allocator_tests.cpp
@@ -5,6 +5,7 @@
 #include <support/allocators/mt_pooled_secure.h>
 #include <support/lockedpool.h>
 
+#include <common/system.h>
 #include <limits>
 #include <memory>
 #include <stdexcept>
diff --git a/src/test/argsman_tests.cpp b/src/test/argsman_tests.cpp
index af3e560f5f47..48bc5e99a3a4 100644
--- a/src/test/argsman_tests.cpp
+++ b/src/test/argsman_tests.cpp
@@ -2,14 +2,15 @@
 // 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 <sync.h>
 #include <test/util/logging.h>
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 #include <util/fs.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 
 #include <array>
 #include <optional>
@@ -84,7 +85,7 @@ class CheckValueTest : public TestChain100Setup
 {
 public:
     struct Expect {
-        util::SettingsValue setting;
+        common::SettingsValue setting;
         bool default_string = false;
         bool default_int = false;
         bool default_bool = false;
@@ -94,7 +95,7 @@ class CheckValueTest : public TestChain100Setup
         std::optional<std::vector<std::string>> list_value;
         const char* error = nullptr;
 
-        explicit Expect(util::SettingsValue s) : setting(std::move(s)) {}
+        explicit Expect(common::SettingsValue s) : setting(std::move(s)) {}
         Expect& DefaultString() { default_string = true; return *this; }
         Expect& DefaultInt() { default_int = true; return *this; }
         Expect& DefaultBool() { default_bool = true; return *this; }
@@ -254,7 +255,7 @@ BOOST_AUTO_TEST_CASE(util_ParseInvalidParameters)
     BOOST_CHECK(!test.ParseParameters(2, argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered");
 
-    // Make sure registered parameters prefixed with a chain name trigger errors.
+    // Make sure registered parameters prefixed with a chain type trigger errors.
     // (Previously, they were accepted and ignored.)
     argv[1] = "-test.registered";
     BOOST_CHECK(!test.ParseParameters(2, argv, error));
@@ -580,7 +581,7 @@ BOOST_AUTO_TEST_CASE(util_ReadConfigStream)
     test_args.SetNetworkOnlyArg("-ccc");
     test_args.SetNetworkOnlyArg("-h");
 
-    test_args.SelectConfigNetwork(CBaseChainParams::MAIN);
+    test_args.SelectConfigNetwork(ChainTypeToString(ChainType::MAIN));
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
@@ -637,7 +638,7 @@ BOOST_AUTO_TEST_CASE(util_GetArg)
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");
 }
 
-BOOST_AUTO_TEST_CASE(util_GetChainName)
+BOOST_AUTO_TEST_CASE(util_GetChainTypeString)
 {
     TestArgsManager test_args;
     const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY);
@@ -655,39 +656,39 @@ BOOST_AUTO_TEST_CASE(util_GetChainName)
     std::string error;
 
     BOOST_CHECK(test_args.ParseParameters(0, argv_testnet, error));
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main");
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_testnet, error));
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "regtest");
 
     BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
-    BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
+    BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(0, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
+    BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
+    BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
     // check setting the network to test (and thus making
     // [test] regtest=1 potentially relevant) doesn't break things
@@ -695,23 +696,23 @@ BOOST_AUTO_TEST_CASE(util_GetChainName)
 
     BOOST_CHECK(test_args.ParseParameters(0, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
+    BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(2, argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
+    BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
     test_args.ReadConfigString(testnetconf);
-    BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
+    BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 }
 
 // Test different ways settings can be merged, and verify results. This test can
@@ -755,8 +756,8 @@ struct ArgsMergeTestingSetup : public BasicTestingSetup {
             ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
                 for (bool soft_set : {false, true}) {
                     for (bool force_set : {false, true}) {
-                        for (const std::string& section : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::DEVNET}) {
-                            for (const std::string& network : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::DEVNET}) {
+                        for (const std::string& section : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::DEVNET)}) {
+                            for (const std::string& network : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::DEVNET)}) {
                                 for (bool net_specific : {false, true}) {
                                     fn(arg_actions, conf_actions, soft_set, force_set, section, network, net_specific);
                                 }
@@ -913,7 +914,7 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
     BOOST_CHECK_EQUAL(out_sha_hex, "c78db4195fcbe4cf3f535f9a72b963bba77fd36099da29dfb8845291a2cf760a");
 }
 
-// Similar test as above, but for ArgsManager::GetChainName function.
+// Similar test as above, but for ArgsManager::GetChainTypeString function.
 struct ChainMergeTestingSetup : public BasicTestingSetup {
     static constexpr int MAX_ACTIONS = 2;
 
@@ -982,7 +983,7 @@ BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup)
 
         desc += " || ";
         try {
-            desc += parser.GetChainName();
+            desc += parser.GetChainTypeString();
         } catch (const std::runtime_error& e) {
             desc += "error: ";
             desc += e.what();
@@ -1021,14 +1022,14 @@ BOOST_AUTO_TEST_CASE(util_ReadWriteSettings)
     // Test writing setting.
     TestArgsManager args1;
     args1.ForceSetArg("-datadir", fs::PathToString(m_path_root));
-    args1.LockSettings([&](util::Settings& settings) { settings.rw_settings["name"] = "value"; });
+    args1.LockSettings([&](common::Settings& settings) { settings.rw_settings["name"] = "value"; });
     args1.WriteSettingsFile();
 
     // Test reading setting.
     TestArgsManager args2;
     args2.ForceSetArg("-datadir", fs::PathToString(m_path_root));
     args2.ReadSettingsFile();
-    args2.LockSettings([&](util::Settings& settings) { BOOST_CHECK_EQUAL(settings.rw_settings["name"].get_str(), "value"); });
+    args2.LockSettings([&](common::Settings& settings) { BOOST_CHECK_EQUAL(settings.rw_settings["name"].get_str(), "value"); });
 
     // Test error logging, and remove previously written setting.
     {
diff --git a/src/test/baseindex_tests.cpp b/src/test/baseindex_tests.cpp
index bf3117554bf4..68c1d63a7704 100644
--- a/src/test/baseindex_tests.cpp
+++ b/src/test/baseindex_tests.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
+#include <common/system.h>
 #include <consensus/validation.h>
 #include <index/coinstatsindex.h>
 #include <interfaces/chain.h>
@@ -11,7 +12,6 @@
 #include <test/util/index.h>
 #include <test/util/setup_common.h>
 #include <util/check.h>
-#include <util/system.h>
 #include <validation.h>
 #include <validationinterface.h>
 
diff --git a/src/test/bip324_tests.cpp b/src/test/bip324_tests.cpp
index 5d6bef2ec7eb..1f76ad55831c 100644
--- a/src/test/bip324_tests.cpp
+++ b/src/test/bip324_tests.cpp
@@ -163,7 +163,7 @@ BOOST_FIXTURE_TEST_SUITE(bip324_tests, BasicTestingSetup)
 BOOST_AUTO_TEST_CASE(packet_test_vectors) {
     // BIP324 key derivation uses network magic in the HKDF process. We use mainnet params here
     // as that is what the test vectors are written for.
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 
     // The test vectors are converted using the following Python code in the BIP bip-0324/ directory:
     //
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 6c55b711b780..b9edaefc2724 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -25,7 +25,7 @@ struct TestChainBRRBeforeActivationSetup : public TestChainSetup
 {
     // Force fast DIP3 activation
     TestChainBRRBeforeActivationSetup() :
-        TestChainSetup(497, CBaseChainParams::REGTEST,
+        TestChainSetup(497, ChainType::REGTEST,
                        {"-dip3params=30:50", "-testactivationheight=brr@1000", "-testactivationheight=v20@1200", "-testactivationheight=mn_rr@2200"})
     {
     }
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index ba5db2a09f0c..10f4b7c53325 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -20,6 +20,7 @@
 #include <future>
 
 using node::BlockAssembler;
+using node::BlockManager;
 using node::CBlockTemplate;
 
 BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
@@ -30,10 +31,10 @@ struct BuildChainTestingSetup : public TestChain100Setup {
 };
 
 static bool CheckFilterLookups(BlockFilterIndex& filter_index, const CBlockIndex* block_index,
-                               uint256& last_header)
+                               uint256& last_header, const BlockManager& blockman)
 {
     BlockFilter expected_filter;
-    if (!ComputeFilter(filter_index.GetFilterType(), block_index, expected_filter)) {
+    if (!ComputeFilter(filter_index.GetFilterType(), *block_index, expected_filter, blockman)) {
         BOOST_ERROR("ComputeFilter failed on block " << block_index->nHeight);
         return false;
     }
@@ -151,7 +152,7 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
         for (block_index = m_node.chainman->ActiveChain().Genesis();
              block_index != nullptr;
              block_index = m_node.chainman->ActiveChain().Next(block_index)) {
-            CheckFilterLookups(filter_index, block_index, last_header);
+            CheckFilterLookups(filter_index, block_index, last_header, m_node.chainman->m_blockman);
         }
     }
 
@@ -184,7 +185,7 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, chainA_last_header);
+        CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
     }
 
     // Reorg to chain B.
@@ -202,7 +203,7 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, chainB_last_header);
+        CheckFilterLookups(filter_index, block_index, chainB_last_header, m_node.chainman->m_blockman);
     }
 
     // Check that filters for stale blocks on A can be retrieved.
@@ -216,7 +217,7 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, chainA_last_header);
+        CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
     }
 
     // Reorg back to chain A.
@@ -236,14 +237,14 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
              block_index = m_node.chainman->m_blockman.LookupBlockIndex(chainA[i]->GetHash());
          }
          BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-         CheckFilterLookups(filter_index, block_index, chainA_last_header);
+         CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
 
          {
              LOCK(cs_main);
              block_index = m_node.chainman->m_blockman.LookupBlockIndex(chainB[i]->GetHash());
          }
          BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-         CheckFilterLookups(filter_index, block_index, chainB_last_header);
+         CheckFilterLookups(filter_index, block_index, chainB_last_header, m_node.chainman->m_blockman);
      }
 
     // Test lookups for a range of filters/hashes.
diff --git a/src/test/blockmanager_tests.cpp b/src/test/blockmanager_tests.cpp
index f70cbc2c2ba3..0dc7d180c777 100644
--- a/src/test/blockmanager_tests.cpp
+++ b/src/test/blockmanager_tests.cpp
@@ -6,6 +6,7 @@
 #include <node/blockstorage.h>
 #include <node/context.h>
 #include <streams.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
@@ -14,16 +15,16 @@
 using node::BlockManager;
 using node::BLOCK_SERIALIZATION_HEADER_SIZE;
 using node::MAX_BLOCKFILE_SIZE;
-using node::OpenBlockFile;
 
 // use BasicTestingSetup here for the data directory configuration, setup, and cleanup
 BOOST_FIXTURE_TEST_SUITE(blockmanager_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(blockmanager_find_block_pos)
 {
-    const auto params {CreateChainParams(ArgsManager{}, CBaseChainParams::MAIN)};
-    node::BlockManager::Options blockman_opts{
+    const auto params {CreateChainParams(ArgsManager{}, ChainType::MAIN)};
+    const BlockManager::Options blockman_opts{
         .chainparams = *params,
+        .blocks_dir = m_args.GetBlocksDirPath(),
     };
     BlockManager blockman{blockman_opts};
     // simulate adding a genesis block normally
@@ -66,13 +67,13 @@ BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain
     // Check that the file is not unlinked after ScanAndUnlinkAlreadyPrunedFiles
     // if m_have_pruned is not yet set
     WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
-    BOOST_CHECK(!CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull());
+    BOOST_CHECK(!CAutoFile(blockman.OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull());
 
     // Check that the file is unlinked after ScanAndUnlinkAlreadyPrunedFiles
     // once m_have_pruned is set
     blockman.m_have_pruned = true;
     WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
-    BOOST_CHECK(CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull());
+    BOOST_CHECK(CAutoFile(blockman.OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull());
 
     // Check that calling with already pruned files doesn't cause an error
     WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
@@ -82,7 +83,7 @@ BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain
     BOOST_CHECK_NE(old_tip, new_tip);
     const int new_file_number{WITH_LOCK(chainman.GetMutex(), return new_tip->GetBlockPos().nFile)};
     const FlatFilePos new_pos(new_file_number, 0);
-    BOOST_CHECK(!CAutoFile(OpenBlockFile(new_pos, true), SER_DISK, CLIENT_VERSION).IsNull());
+    BOOST_CHECK(!CAutoFile(blockman.OpenBlockFile(new_pos, true), SER_DISK, CLIENT_VERSION).IsNull());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/bloom_tests.cpp b/src/test/bloom_tests.cpp
index eb061d084300..30d8d7e0a881 100644
--- a/src/test/bloom_tests.cpp
+++ b/src/test/bloom_tests.cpp
@@ -5,6 +5,7 @@
 #include <bls/bls.h>
 #include <clientversion.h>
 #include <common/bloom.h>
+#include <common/system.h>
 #include <key.h>
 #include <key_io.h>
 #include <merkleblock.h>
diff --git a/src/test/checkqueue_tests.cpp b/src/test/checkqueue_tests.cpp
index bac14cb68722..f986c14234d7 100644
--- a/src/test/checkqueue_tests.cpp
+++ b/src/test/checkqueue_tests.cpp
@@ -2,11 +2,12 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <test/util/setup_common.h>
-
 #include <checkqueue.h>
+#include <common/args.h>
 #include <sync.h>
 #include <test/util/random.h>
+#include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <util/time.h>
 
 #include <boost/test/unit_test.hpp>
@@ -26,9 +27,9 @@
 struct NoLockLoggingTestingSetup : public TestingSetup {
     NoLockLoggingTestingSetup()
 #ifdef DEBUG_LOCKCONTENTION
-        : TestingSetup{CBaseChainParams::MAIN, /*extra_args=*/{"-debugexclude=lock"}} {}
+        : TestingSetup{ChainType::MAIN, /*extra_args=*/{"-debugexclude=lock"}} {}
 #else
-        : TestingSetup{CBaseChainParams::MAIN} {}
+        : TestingSetup{ChainType::MAIN} {}
 #endif
 };
 
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index eb3f1c308556..c286816d919a 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -6,6 +6,7 @@
 
 #include <banman.h>
 #include <chainparams.h>
+#include <common/args.h>
 #include <net.h>
 #include <net_processing.h>
 #include <pubkey.h>
@@ -17,7 +18,6 @@
 #include <test/util/setup_common.h>
 #include <timedata.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
diff --git a/src/test/dynamic_activation_thresholds_tests.cpp b/src/test/dynamic_activation_thresholds_tests.cpp
index a875f8b6478e..8d3842d3bc21 100644
--- a/src/test/dynamic_activation_thresholds_tests.cpp
+++ b/src/test/dynamic_activation_thresholds_tests.cpp
@@ -30,7 +30,7 @@ static constexpr int threshold(int attempt)
 struct TestChainDATSetup : public TestChainSetup
 {
     TestChainDATSetup() :
-        TestChainSetup(window - 2, CBaseChainParams::REGTEST, {"-vbparams=testdummy:0:999999999999:0:20:16:12:5:0"}) {}
+        TestChainSetup(window - 2, ChainType::REGTEST, {"-vbparams=testdummy:0:999999999999:0:20:16:12:5:0"}) {}
 
     void signal(int num_blocks, bool expected_lockin)
     {
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index aa23c80aa846..5a396b83dcf1 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -863,7 +863,7 @@ BOOST_FIXTURE_TEST_CASE(min_blocks_to_keep_covers_credit_pool_rebuild, BasicTest
 {
     // A pool is rebuilt from a snapshot up to one period old, reading the block one window before
     // each block since it. Regtest deliberately keeps Bitcoin Core's 288 and is not checked.
-    for (const auto& chain : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::DEVNET}) {
+    for (const auto& chain : {ChainType::MAIN, ChainType::TESTNET, ChainType::DEVNET}) {
         const auto params = CreateChainParams(*m_node.args, chain);
         BOOST_CHECK_GE(params->MinBlocksToKeep(),
                        CCreditPoolManager::DISK_SNAPSHOT_PERIOD + params->CreditPoolPeriodBlocks());
diff --git a/src/test/evo_cbtx_tests.cpp b/src/test/evo_cbtx_tests.cpp
index 090ac9de96b2..80e85268a4bf 100644
--- a/src/test/evo_cbtx_tests.cpp
+++ b/src/test/evo_cbtx_tests.cpp
@@ -73,13 +73,13 @@ BOOST_FIXTURE_TEST_CASE(check_cbtx_best_chainlock_rejects_excessive_height_diff,
     // bestCLHeightDiff == nHeight: lower boundary of the rejected range.
     cbTx.bestCLHeightDiff = static_cast<uint32_t>(pindex.nHeight);
     BlockValidationState state;
-    BOOST_CHECK(!CheckCbTxBestChainlock(cbTx, &pindex, consensus_params, chain, qman, chainlocks, state));
+    BOOST_CHECK(!CheckCbTxBestChainlock(cbTx, &pindex, consensus_params, m_node.chainman->m_blockman, chain, qman, chainlocks, state));
     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cbtx-cldiff");
 
     // Upper boundary: uint32_t max.
     cbTx.bestCLHeightDiff = std::numeric_limits<uint32_t>::max();
     BlockValidationState state_big;
-    BOOST_CHECK(!CheckCbTxBestChainlock(cbTx, &pindex, consensus_params, chain, qman, chainlocks, state_big));
+    BOOST_CHECK(!CheckCbTxBestChainlock(cbTx, &pindex, consensus_params, m_node.chainman->m_blockman, chain, qman, chainlocks, state_big));
     BOOST_CHECK_EQUAL(state_big.GetRejectReason(), "bad-cbtx-cldiff");
 
     // The signature is deserialized lazily, so the payload parser accepts any bytes in its
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index 1728ef9b55dd..6b51efa721a9 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -2384,7 +2384,7 @@ void FuncVerifyDB(TestChainSetup& setup)
 
     // Verify db consistency
     LOCK(cs_main);
-    BOOST_REQUIRE(CVerifyDB().VerifyDB(chainman.ActiveChainstate(), Params().GetConsensus(),
+    BOOST_REQUIRE(CVerifyDB(chainman.GetNotifications()).VerifyDB(chainman.ActiveChainstate(), Params().GetConsensus(),
                                        chainman.ActiveChainstate().CoinsTip(), *(setup.m_node.evodb), 4, 2) == VerifyDBResult::SUCCESS);
 }
 
@@ -2509,7 +2509,7 @@ BOOST_AUTO_TEST_CASE(deterministic_mn_list_diff_serialization_is_canonical)
 
 struct TestChainDIP3BeforeActivationSetup : public TestChainSetup {
     TestChainDIP3BeforeActivationSetup() :
-        TestChainSetup(DIP3_ACTIVATION_HEIGHT - 2, CBaseChainParams::REGTEST, {"-dip3params=109:500"},
+        TestChainSetup(DIP3_ACTIVATION_HEIGHT - 2, ChainType::REGTEST, {"-dip3params=109:500"},
                        /*coins_db_in_memory=*/true, /*block_tree_db_in_memory=*/true)
     {
     }
@@ -2525,7 +2525,7 @@ struct TestChainDIP3Setup : public TestChainDIP3BeforeActivationSetup {
 
 struct TestMNChainSetup : public TestChainSetup {
     TestMNChainSetup(int num_blocks, const std::vector<const char*>& extra_args) :
-        TestChainSetup(num_blocks, CBaseChainParams::REGTEST, extra_args,
+        TestChainSetup(num_blocks, ChainType::REGTEST, extra_args,
                        /*coins_db_in_memory=*/true, /*block_tree_db_in_memory=*/true),
         chainman(*Assert(m_node.chainman)),
         dmnman(*Assert(m_node.dmnman)),
@@ -4675,7 +4675,7 @@ BOOST_AUTO_TEST_CASE(evodb_repair_missing_snapshot_is_repair_error)
                                     const CCoinsViewCache&, bool, BlockValidationState&,
                                     CDeterministicMNList&) { return false; };
 
-    auto result = dmnman.RecalculateAndRepairDiffs(dip3_index, second_index, build_list_func, /*repair=*/true);
+    auto result = dmnman.RecalculateAndRepairDiffs(chainman.m_blockman, dip3_index, second_index, build_list_func, /*repair=*/true);
     BOOST_CHECK(result.verification_errors.empty());
     BOOST_CHECK(result.repair_errors.empty());
     BOOST_CHECK_EQUAL(result.snapshots_verified, 2);
@@ -4691,19 +4691,19 @@ BOOST_AUTO_TEST_CASE(evodb_repair_missing_snapshot_is_repair_error)
     const std::string missing_msg{strprintf("Snapshot missing at height %d", snapshot_period)};
 
     // Snapshot missing as the end of a pair
-    result = dmnman.RecalculateAndRepairDiffs(dip3_index, second_index, build_list_func, /*repair=*/true);
+    result = dmnman.RecalculateAndRepairDiffs(chainman.m_blockman, dip3_index, second_index, build_list_func, /*repair=*/true);
     BOOST_CHECK(result.verification_errors.empty());
     BOOST_REQUIRE_EQUAL(result.repair_errors.size(), 1U);
     BOOST_CHECK(result.repair_errors[0].find(missing_msg) != std::string::npos);
 
     // Snapshot missing as the start of a pair
-    result = dmnman.RecalculateAndRepairDiffs(first_index, second_index, build_list_func, /*repair=*/true);
+    result = dmnman.RecalculateAndRepairDiffs(chainman.m_blockman, first_index, second_index, build_list_func, /*repair=*/true);
     BOOST_CHECK(result.verification_errors.empty());
     BOOST_REQUIRE_EQUAL(result.repair_errors.size(), 1U);
     BOOST_CHECK(result.repair_errors[0].find(missing_msg) != std::string::npos);
 
     // Verify-only mode has no repair errors to report
-    result = dmnman.RecalculateAndRepairDiffs(dip3_index, second_index, build_list_func, /*repair=*/false);
+    result = dmnman.RecalculateAndRepairDiffs(chainman.m_blockman, dip3_index, second_index, build_list_func, /*repair=*/false);
     BOOST_CHECK(result.repair_errors.empty());
     BOOST_REQUIRE_EQUAL(result.verification_errors.size(), 1U);
     BOOST_CHECK(result.verification_errors[0].find(missing_msg) != std::string::npos);
diff --git a/src/test/evo_netinfo_tests.cpp b/src/test/evo_netinfo_tests.cpp
index 99c539f91e34..04c6fa39cfe0 100644
--- a/src/test/evo_netinfo_tests.cpp
+++ b/src/test/evo_netinfo_tests.cpp
@@ -302,7 +302,7 @@ BOOST_AUTO_TEST_CASE(provider_network_fields_main)
 }
 
 struct TestNetSetup : public BasicTestingSetup {
-    TestNetSetup() : BasicTestingSetup{CBaseChainParams::TESTNET} {}
+    TestNetSetup() : BasicTestingSetup{ChainType::TESTNET} {}
 };
 
 BOOST_FIXTURE_TEST_CASE(extnetinfo_ports_mainnet_only, TestNetSetup)
@@ -351,7 +351,7 @@ BOOST_FIXTURE_TEST_CASE(extnetinfo_ports_mainnet_only, TestNetSetup)
 
     // A serialized ProTx carries its entries as-is, so consensus on mainnet must apply the rules to the
     // same objects even though they never passed through AddEntry() there
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
     for (size_t idx{0}; idx < vals.size(); ++idx) {
         const auto& [type, _, valid_on_mainnet] = vals[idx];
         const auto net_info{std::make_shared<ExtNetInfo>(deserialize, serialized[idx])};
@@ -360,7 +360,7 @@ BOOST_FIXTURE_TEST_CASE(extnetinfo_ports_mainnet_only, TestNetSetup)
         BOOST_CHECK_EQUAL(check_fields(net_info, type, state), valid_on_mainnet);
         BOOST_CHECK_EQUAL(state.GetRejectReason(), valid_on_mainnet ? "" : "bad-protx-netinfo-port");
     }
-    SelectParams(CBaseChainParams::TESTNET);
+    SelectParams(ChainType::TESTNET);
 }
 
 BOOST_FIXTURE_TEST_CASE(ipv4_primaries_follow_activation, TestNetSetup)
@@ -426,11 +426,11 @@ BOOST_FIXTURE_TEST_CASE(ipv4_primaries_follow_activation, TestNetSetup)
 
     // The rule depends on the activation, not the network. Validate(), which also checks stored masternode states
     // without a height, doesn't apply it.
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
     for (size_t idx{0}; idx < vals.size(); ++idx) {
         check(std::make_shared<ExtNetInfo>(deserialize, serialized[idx]), vals[idx]);
     }
-    SelectParams(CBaseChainParams::TESTNET);
+    SelectParams(ChainType::TESTNET);
 }
 
 static const std::vector<TestEntry> addr_vals_reg{
diff --git a/src/test/evo_trivialvalidation.cpp b/src/test/evo_trivialvalidation.cpp
index 0f6772806a20..a7e9a77c54d9 100644
--- a/src/test/evo_trivialvalidation.cpp
+++ b/src/test/evo_trivialvalidation.cpp
@@ -28,7 +28,7 @@
 
 struct TestChain100V19Activation : public TestChain100Setup {
     TestChain100V19Activation()
-        : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=v19@100"}} {}
+        : TestChain100Setup{ChainType::REGTEST, {"-testactivationheight=v19@100"}} {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(evo_trivialvalidation, TestChain100V19Activation)
diff --git a/src/test/flatfile_tests.cpp b/src/test/flatfile_tests.cpp
index 54c30ed314d6..3874b38f613e 100644
--- a/src/test/flatfile_tests.cpp
+++ b/src/test/flatfile_tests.cpp
@@ -3,10 +3,10 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <clientversion.h>
+#include <common/args.h>
 #include <flatfile.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
-#include <util/system.h>
 
 #include <boost/test/unit_test.hpp>
 
diff --git a/src/test/fuzz/addrman.cpp b/src/test/fuzz/addrman.cpp
index a97c2b538ce1..825ece94c2a8 100644
--- a/src/test/fuzz/addrman.cpp
+++ b/src/test/fuzz/addrman.cpp
@@ -6,6 +6,7 @@
 #include <addrman.h>
 #include <addrman_impl.h>
 #include <chainparams.h>
+#include <common/args.h>
 #include <merkleblock.h>
 #include <random.h>
 #include <test/fuzz/FuzzedDataProvider.h>
@@ -15,7 +16,7 @@
 #include <test/util/setup_common.h>
 #include <time.h>
 #include <util/asmap.h>
-#include <util/system.h>
+#include <util/chaintype.h>
 
 #include <cassert>
 #include <cstdint>
@@ -34,7 +35,7 @@ int32_t GetCheckRatio()
 
 void initialize_addrman()
 {
-    static const auto testing_setup = MakeNoLogFileContext<>(CBaseChainParams::REGTEST);
+    static const auto testing_setup = MakeNoLogFileContext<>(ChainType::REGTEST);
     g_setup = testing_setup.get();
 }
 
diff --git a/src/test/fuzz/banman.cpp b/src/test/fuzz/banman.cpp
index 5d08ea4ae9c3..b26151f63c83 100644
--- a/src/test/fuzz/banman.cpp
+++ b/src/test/fuzz/banman.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <banman.h>
+#include <common/args.h>
 #include <netaddress.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
@@ -11,7 +12,6 @@
 #include <test/util/setup_common.h>
 #include <util/fs.h>
 #include <util/readwritefile.h>
-#include <util/system.h>
 
 #include <cassert>
 #include <cstdint>
diff --git a/src/test/fuzz/bip324.cpp b/src/test/fuzz/bip324.cpp
index 56ee0f58a92d..47f37b76226f 100644
--- a/src/test/fuzz/bip324.cpp
+++ b/src/test/fuzz/bip324.cpp
@@ -16,7 +16,7 @@
 void initialize_bip324()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 FUZZ_TARGET(bip324_cipher_roundtrip, .init = initialize_bip324)
diff --git a/src/test/fuzz/block.cpp b/src/test/fuzz/block.cpp
index 3d21c6ba200c..d5b60907cbe4 100644
--- a/src/test/fuzz/block.cpp
+++ b/src/test/fuzz/block.cpp
@@ -11,6 +11,7 @@
 #include <pubkey.h>
 #include <streams.h>
 #include <test/fuzz/fuzz.h>
+#include <util/chaintype.h>
 #include <validation.h>
 #include <version.h>
 
@@ -19,7 +20,7 @@
 
 void initialize_block()
 {
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(block, .init = initialize_block)
diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
index 8ac63b9af699..0bd7dd402dda 100644
--- a/src/test/fuzz/coins_view.cpp
+++ b/src/test/fuzz/coins_view.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <chainparams.h>
 #include <chainparamsbase.h>
 #include <coins.h>
 #include <consensus/amount.h>
diff --git a/src/test/fuzz/connman.cpp b/src/test/fuzz/connman.cpp
index 30dc425d1d4a..9b43302a15cf 100644
--- a/src/test/fuzz/connman.cpp
+++ b/src/test/fuzz/connman.cpp
@@ -4,7 +4,7 @@
 
 #include <addrman.h>
 #include <chainparams.h>
-#include <chainparamsbase.h>
+#include <common/args.h>
 #include <net.h>
 #include <netaddress.h>
 #include <protocol.h>
@@ -13,7 +13,6 @@
 #include <test/fuzz/util.h>
 #include <test/fuzz/util/net.h>
 #include <test/util/setup_common.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <cstdint>
diff --git a/src/test/fuzz/descriptor_parse.cpp b/src/test/fuzz/descriptor_parse.cpp
index dd92c4f56255..74c598e655b8 100644
--- a/src/test/fuzz/descriptor_parse.cpp
+++ b/src/test/fuzz/descriptor_parse.cpp
@@ -10,6 +10,7 @@
 #include <script/standard.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util/descriptor.h>
+#include <util/chaintype.h>
 
 //! The converter of mocked descriptors, needs to be initialized when the target is.
 MockedDescriptorConverter MOCKED_DESC_CONVERTER;
@@ -44,7 +45,7 @@ static void TestDescriptor(const Descriptor& desc, FlatSigningProvider& sig_prov
 void initialize_descriptor_parse()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 void initialize_mocked_descriptor_parse()
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index 1b61a6f767e1..0d267e64d87a 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -9,6 +9,7 @@
 #include <blockfilter.h>
 #include <chain.h>
 #include <coins.h>
+#include <common/args.h>
 #include <compressor.h>
 #include <consensus/merkle.h>
 #include <key.h>
@@ -26,7 +27,6 @@
 #include <test/fuzz/util.h>
 #include <test/util/setup_common.h>
 #include <undo.h>
-#include <util/system.h>
 #include <version.h>
 
 #include <exception>
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
index bc1bec691241..381da4bcc26f 100644
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -4,6 +4,8 @@
 
 #include <arith_uint256.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <compressor.h>
 #include <consensus/amount.h>
 #include <consensus/merkle.h>
@@ -27,12 +29,12 @@
 #include <test/fuzz/util.h>
 #include <uint256.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <util/moneystr.h>
 #include <util/overflow.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <version.h>
 
 #include <cassert>
@@ -44,7 +46,7 @@
 
 void initialize_integer()
 {
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(integer, .init = initialize_integer)
diff --git a/src/test/fuzz/key.cpp b/src/test/fuzz/key.cpp
index c0f1fd075ee2..eb901f464b67 100644
--- a/src/test/fuzz/key.cpp
+++ b/src/test/fuzz/key.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <chainparamsbase.h>
 #include <key.h>
 #include <key_io.h>
 #include <policy/policy.h>
@@ -16,6 +15,7 @@
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
+#include <util/chaintype.h>
 #include <util/strencodings.h>
 
 #include <algorithm>
@@ -31,7 +31,7 @@
 void initialize_key()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(key, .init = initialize_key)
diff --git a/src/test/fuzz/key_io.cpp b/src/test/fuzz/key_io.cpp
index aa9338259a25..5f98f2b7f1b2 100644
--- a/src/test/fuzz/key_io.cpp
+++ b/src/test/fuzz/key_io.cpp
@@ -5,6 +5,7 @@
 #include <chainparams.h>
 #include <key_io.h>
 #include <test/fuzz/fuzz.h>
+#include <util/chaintype.h>
 
 #include <cassert>
 #include <cstdint>
@@ -14,7 +15,7 @@
 void initialize_key_io()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 FUZZ_TARGET(key_io, .init = initialize_key_io)
diff --git a/src/test/fuzz/message.cpp b/src/test/fuzz/message.cpp
index acbe5eb0749e..4c7139875095 100644
--- a/src/test/fuzz/message.cpp
+++ b/src/test/fuzz/message.cpp
@@ -7,6 +7,7 @@
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
+#include <util/chaintype.h>
 #include <util/message.h>
 #include <util/strencodings.h>
 
@@ -19,7 +20,7 @@
 void initialize_message()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(message, .init = initialize_message)
diff --git a/src/test/fuzz/net.cpp b/src/test/fuzz/net.cpp
index eae12faa41da..20f1d779c9a4 100644
--- a/src/test/fuzz/net.cpp
+++ b/src/test/fuzz/net.cpp
@@ -4,7 +4,6 @@
 
 #include <addrman.h>
 #include <chainparams.h>
-#include <chainparamsbase.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <netaddress.h>
@@ -17,6 +16,7 @@
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <util/asmap.h>
+#include <util/chaintype.h>
 
 #include <cstdint>
 #include <optional>
@@ -34,7 +34,7 @@ int32_t GetCheckRatio()
 
 void initialize_net()
 {
-    static const auto testing_setup = MakeNoLogFileContext<>(CBaseChainParams::MAIN);
+    static const auto testing_setup = MakeNoLogFileContext<>(ChainType::MAIN);
     g_setup = testing_setup.get();
 }
 
diff --git a/src/test/fuzz/p2p_transport_serialization.cpp b/src/test/fuzz/p2p_transport_serialization.cpp
index 95e1a618fba3..10953cf169e5 100644
--- a/src/test/fuzz/p2p_transport_serialization.cpp
+++ b/src/test/fuzz/p2p_transport_serialization.cpp
@@ -11,6 +11,7 @@
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/util/xoroshiro128plusplus.h>
+#include <util/chaintype.h>
 
 #include <cassert>
 #include <cstdint>
@@ -23,7 +24,7 @@ std::vector<std::string> g_all_messages;
 void initialize_p2p_transport_serialization()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
     g_all_messages = getAllNetMessageTypes();
     std::sort(g_all_messages.begin(), g_all_messages.end());
 }
diff --git a/src/test/fuzz/parse_univalue.cpp b/src/test/fuzz/parse_univalue.cpp
index 971983762b73..f407c5214690 100644
--- a/src/test/fuzz/parse_univalue.cpp
+++ b/src/test/fuzz/parse_univalue.cpp
@@ -8,13 +8,14 @@
 #include <rpc/util.h>
 #include <script/sign.h>
 #include <test/fuzz/fuzz.h>
+#include <util/chaintype.h>
 
 #include <limits>
 #include <string>
 
 void initialize_parse_univalue()
 {
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(parse_univalue, .init = initialize_parse_univalue)
diff --git a/src/test/fuzz/pow.cpp b/src/test/fuzz/pow.cpp
index ce67daa7b253..85bd1e255e45 100644
--- a/src/test/fuzz/pow.cpp
+++ b/src/test/fuzz/pow.cpp
@@ -9,6 +9,7 @@
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <util/overflow.h>
 
@@ -19,7 +20,7 @@
 
 void initialize_pow()
 {
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 FUZZ_TARGET(pow, .init = initialize_pow)
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
index f6fe8ed1caca..f16d0535df2a 100644
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -15,6 +15,7 @@
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
+#include <util/chaintype.h>
 #include <validationinterface.h>
 #include <version.h>
 
@@ -38,7 +39,7 @@ void initialize_process_message()
     }
 
     static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(
-            /*chain_name=*/CBaseChainParams::REGTEST,
+            /*chain_type=*/ChainType::REGTEST,
             /*extra_args=*/{"-txreconciliation"});
     g_setup = testing_setup.get();
     for (int i = 0; i < 2 * COINBASE_MATURITY; i++) {
diff --git a/src/test/fuzz/process_messages.cpp b/src/test/fuzz/process_messages.cpp
index 4bc267c32125..f0293ae80eb0 100644
--- a/src/test/fuzz/process_messages.cpp
+++ b/src/test/fuzz/process_messages.cpp
@@ -24,7 +24,7 @@ const TestingSetup* g_setup;
 void initialize_process_messages()
 {
     static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(
-            /*chain_name=*/CBaseChainParams::REGTEST,
+            /*chain_type=*/ChainType::REGTEST,
             /*extra_args=*/{"-txreconciliation"});
     g_setup = testing_setup.get();
     for (int i = 0; i < 2 * COINBASE_MATURITY; i++) {
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index e943c14c42ed..775ce0e5d7dc 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -20,6 +20,7 @@
 #include <tinyformat.h>
 #include <uint256.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
@@ -38,7 +39,7 @@ enum class ChainType;
 
 namespace {
 struct RPCFuzzTestingSetup : public TestingSetup {
-    RPCFuzzTestingSetup(const std::string& chain_name, const std::vector<const char*>& extra_args) : TestingSetup{chain_name, extra_args}
+    RPCFuzzTestingSetup(const ChainType chain_type, const std::vector<const char*>& extra_args) : TestingSetup{chain_type, extra_args}
     {
     }
 
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index c146c3b4554f..de68a8bed0ea 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -22,6 +22,7 @@
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 
 #include <algorithm>
 #include <cassert>
@@ -32,7 +33,7 @@
 
 void initialize_script()
 {
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(script, .init = initialize_script)
diff --git a/src/test/fuzz/script_format.cpp b/src/test/fuzz/script_format.cpp
index eecfc8960df3..0ab338e4bd19 100644
--- a/src/test/fuzz/script_format.cpp
+++ b/src/test/fuzz/script_format.cpp
@@ -11,10 +11,11 @@
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 
 void initialize_script_format()
 {
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(script_format, .init = initialize_script_format)
diff --git a/src/test/fuzz/script_sigcache.cpp b/src/test/fuzz/script_sigcache.cpp
index 60875f3f9a99..d5b4eb8ea699 100644
--- a/src/test/fuzz/script_sigcache.cpp
+++ b/src/test/fuzz/script_sigcache.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <chainparamsbase.h>
 #include <key.h>
 #include <pubkey.h>
 #include <script/sigcache.h>
diff --git a/src/test/fuzz/script_sign.cpp b/src/test/fuzz/script_sign.cpp
index 0b277a88f5ef..23ce5cd66ed1 100644
--- a/src/test/fuzz/script_sign.cpp
+++ b/src/test/fuzz/script_sign.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <chainparamsbase.h>
 #include <key.h>
 #include <psbt.h>
 #include <pubkey.h>
@@ -14,6 +13,7 @@
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
+#include <util/chaintype.h>
 #include <util/translation.h>
 
 #include <cassert>
@@ -27,7 +27,7 @@
 void initialize_script_sign()
 {
     ECC_Start();
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(script_sign, .init = initialize_script_sign)
diff --git a/src/test/fuzz/string.cpp b/src/test/fuzz/string.cpp
index feabcd5bc396..d6f85a53694b 100644
--- a/src/test/fuzz/string.cpp
+++ b/src/test/fuzz/string.cpp
@@ -4,6 +4,9 @@
 
 #include <blockfilter.h>
 #include <clientversion.h>
+#include <common/args.h>
+#include <common/settings.h>
+#include <common/system.h>
 #include <common/url.h>
 #include <netbase.h>
 #include <rpc/client.h>
@@ -19,10 +22,8 @@
 #include <test/fuzz/util.h>
 #include <util/error.h>
 #include <util/fees.h>
-#include <util/settings.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 
 #include <cassert>
@@ -61,7 +62,7 @@ FUZZ_TARGET(string)
     (void)IsDeprecatedRPCEnabled(random_string_1);
     (void)Join(random_string_vector, random_string_1);
     (void)JSONRPCError(fuzzed_data_provider.ConsumeIntegral<int>(), random_string_1);
-    const util::Settings settings;
+    const common::Settings settings;
     (void)OnlyHasDefaultSectionSetting(settings, random_string_1, random_string_2);
     (void)ParseNetwork(random_string_1);
     (void)RemovePrefix(random_string_1, random_string_2);
diff --git a/src/test/fuzz/system.cpp b/src/test/fuzz/system.cpp
index b0e22851752d..6dfcea0e0b2f 100644
--- a/src/test/fuzz/system.cpp
+++ b/src/test/fuzz/system.cpp
@@ -2,11 +2,11 @@
 // 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 <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/util/setup_common.h>
-#include <util/system.h>
 
 #include <cstdint>
 #include <string>
@@ -55,7 +55,7 @@ FUZZ_TARGET(system, .init = initialize_system)
             [&] {
                 const OptionsCategory options_category = fuzzed_data_provider.PickValueInArray<OptionsCategory>({OptionsCategory::OPTIONS, OptionsCategory::CONNECTION, OptionsCategory::WALLET, OptionsCategory::WALLET_DEBUG_TEST, OptionsCategory::ZMQ, OptionsCategory::DEBUG_TEST, OptionsCategory::CHAINPARAMS, OptionsCategory::NODE_RELAY, OptionsCategory::BLOCK_CREATION, OptionsCategory::RPC, OptionsCategory::GUI, OptionsCategory::COMMANDS, OptionsCategory::REGISTER_COMMANDS, OptionsCategory::HIDDEN});
                 // Avoid hitting:
-                // util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
+                // common/args.cpp:563: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
                 const std::string argument_name = GetArgumentName(fuzzed_data_provider.ConsumeRandomLengthString(16));
                 if (args_manager.GetArgFlags(argument_name) != std::nullopt) {
                     return;
@@ -64,7 +64,7 @@ FUZZ_TARGET(system, .init = initialize_system)
             },
             [&] {
                 // Avoid hitting:
-                // util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
+                // common/args.cpp:563: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
                 const std::vector<std::string> names = ConsumeRandomLengthStringVector(fuzzed_data_provider);
                 std::vector<std::string> hidden_arguments;
                 for (const std::string& name : names) {
@@ -108,7 +108,7 @@ FUZZ_TARGET(system, .init = initialize_system)
     (void)args_manager.GetArgs(s1);
     (void)args_manager.GetBoolArg(s1, b);
     try {
-        (void)args_manager.GetChainName();
+        (void)args_manager.GetChainTypeString();
     } catch (const std::runtime_error&) {
     }
     (void)args_manager.GetHelpMessage();
diff --git a/src/test/fuzz/transaction.cpp b/src/test/fuzz/transaction.cpp
index 9b649dc9c655..d17cbe8a2a29 100644
--- a/src/test/fuzz/transaction.cpp
+++ b/src/test/fuzz/transaction.cpp
@@ -15,6 +15,7 @@
 #include <streams.h>
 #include <test/fuzz/fuzz.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 #include <validation.h>
 #include <version.h>
 
@@ -22,7 +23,7 @@
 
 void initialize_transaction()
 {
-    SelectParams(CBaseChainParams::REGTEST);
+    SelectParams(ChainType::REGTEST);
 }
 
 FUZZ_TARGET(transaction, .init = initialize_transaction)
diff --git a/src/test/fuzz/util.h b/src/test/fuzz/util.h
index 37202db70ea5..71b330089967 100644
--- a/src/test/fuzz/util.h
+++ b/src/test/fuzz/util.h
@@ -6,7 +6,6 @@
 #define BITCOIN_TEST_FUZZ_UTIL_H
 
 #include <arith_uint256.h>
-#include <chainparamsbase.h>
 #include <coins.h>
 #include <compat/compat.h>
 #include <consensus/amount.h>
diff --git a/src/test/fuzz/utxo_snapshot.cpp b/src/test/fuzz/utxo_snapshot.cpp
index e6eec15d9ea8..5412f57d1249 100644
--- a/src/test/fuzz/utxo_snapshot.cpp
+++ b/src/test/fuzz/utxo_snapshot.cpp
@@ -10,6 +10,7 @@
 #include <test/fuzz/util.h>
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <util/fs.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -22,7 +23,7 @@ const std::vector<std::shared_ptr<CBlock>>* g_chain;
 
 void initialize_chain()
 {
-    const auto params{CreateChainParams(ArgsManager{}, CBaseChainParams::REGTEST)};
+    const auto params{CreateChainParams(ArgsManager{}, ChainType::REGTEST)};
     static const auto chain{CreateBlockChain(2 * COINBASE_MATURITY, *params)};
     g_chain = &chain;
 }
diff --git a/src/test/fuzz/utxo_total_supply.cpp b/src/test/fuzz/utxo_total_supply.cpp
index 30be9e007a6f..be3ba8c172c3 100644
--- a/src/test/fuzz/utxo_total_supply.cpp
+++ b/src/test/fuzz/utxo_total_supply.cpp
@@ -14,6 +14,7 @@
 #include <test/fuzz/util.h>
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <validation.h>
 #include <version.h>
 
@@ -21,7 +22,7 @@ FUZZ_TARGET(utxo_total_supply)
 {
     /** The testing setup that creates a chainman only (no chainstate) */
     ChainTestingSetup test_setup{
-        CBaseChainParams::REGTEST,
+        ChainType::REGTEST,
         {
             "-testactivationheight=bip34@2",
         },
diff --git a/src/test/fuzz/validation_load_mempool.cpp b/src/test/fuzz/validation_load_mempool.cpp
index 4805d88cb59e..c203dd4e390a 100644
--- a/src/test/fuzz/validation_load_mempool.cpp
+++ b/src/test/fuzz/validation_load_mempool.cpp
@@ -4,7 +4,6 @@
 
 #include <kernel/mempool_persist.h>
 
-#include <chainparamsbase.h>
 #include <node/mempool_args.h>
 #include <node/mempool_persist_args.h>
 #include <test/fuzz/FuzzedDataProvider.h>
diff --git a/src/test/fuzz/versionbits.cpp b/src/test/fuzz/versionbits.cpp
index 5db0854e93e2..ecce19d2c7d8 100644
--- a/src/test/fuzz/versionbits.cpp
+++ b/src/test/fuzz/versionbits.cpp
@@ -4,9 +4,10 @@
 
 #include <chain.h>
 #include <chainparams.h>
+#include <common/args.h>
 #include <consensus/params.h>
 #include <primitives/block.h>
-#include <util/system.h>
+#include <util/chaintype.h>
 #include <versionbits.h>
 
 #include <test/fuzz/FuzzedDataProvider.h>
@@ -105,7 +106,7 @@ std::unique_ptr<const CChainParams> g_params;
 void initialize_versionbits()
 {
     // this is actually comparatively slow, so only do it once
-    g_params = CreateChainParams(ArgsManager{}, CBaseChainParams::MAIN);
+    g_params = CreateChainParams(ArgsManager{}, ChainType::MAIN);
     assert(g_params != nullptr);
 }
 
diff --git a/src/test/getarg_tests.cpp b/src/test/getarg_tests.cpp
index d71d75b015e7..57f71b708df8 100644
--- a/src/test/getarg_tests.cpp
+++ b/src/test/getarg_tests.cpp
@@ -2,11 +2,12 @@
 // 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 <common/settings.h>
+#include <logging.h>
 #include <test/util/setup_common.h>
 #include <univalue.h>
-#include <util/settings.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 
 #include <limits>
 #include <string>
@@ -56,8 +57,8 @@ BOOST_AUTO_TEST_CASE(setting_args)
     ArgsManager args;
     SetupArgs(args, {{"-foo", ArgsManager::ALLOW_ANY}});
 
-    auto set_foo = [&](const util::SettingsValue& value) {
-      args.LockSettings([&](util::Settings& settings) {
+    auto set_foo = [&](const common::SettingsValue& value) {
+      args.LockSettings([&](common::Settings& settings) {
         settings.rw_settings["foo"] = value;
       });
     };
diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index 8c8c6e8f1278..c93aa6881e82 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -48,7 +48,7 @@ struct EmptyCollateralSource final : public governance::CollateralSource {
 struct GovernanceInvSetup : public TestingSetup {
     EmptyCollateralSource m_collateral;
 
-    GovernanceInvSetup() : TestingSetup{CBaseChainParams::MAIN}
+    GovernanceInvSetup() : TestingSetup{ChainType::MAIN}
     {
         // ConfirmInventoryRequest and the NetGovernance object/vote handlers
         // short-circuit on !IsBlockchainSynced().
diff --git a/src/test/governance_superblock_tests.cpp b/src/test/governance_superblock_tests.cpp
index 14f5c5bb837f..b4e655eb0b09 100644
--- a/src/test/governance_superblock_tests.cpp
+++ b/src/test/governance_superblock_tests.cpp
@@ -19,7 +19,7 @@
 #include <vector>
 
 struct SuperblockRegtestSetup : public BasicTestingSetup {
-    SuperblockRegtestSetup() : BasicTestingSetup(CBaseChainParams::REGTEST) {}
+    SuperblockRegtestSetup() : BasicTestingSetup(ChainType::REGTEST) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(governance_superblock_tests, SuperblockRegtestSetup)
diff --git a/src/test/governance_vote_processing_tests.cpp b/src/test/governance_vote_processing_tests.cpp
index eb834ee8b4ec..357e7e0e1789 100644
--- a/src/test/governance_vote_processing_tests.cpp
+++ b/src/test/governance_vote_processing_tests.cpp
@@ -88,7 +88,7 @@ struct GovernanceVoteSetup : public TestChainSetup {
     std::string proposal_payment_address;
 
     GovernanceVoteSetup() :
-        TestChainSetup(DIP3_ACTIVATION_HEIGHT - 2, CBaseChainParams::REGTEST, {"-dip3params=109:500"})
+        TestChainSetup(DIP3_ACTIVATION_HEIGHT - 2, ChainType::REGTEST, {"-dip3params=109:500"})
     {
         // A failed BOOST_REQUIRE below throws, and a throwing constructor means no destructor runs.
         // Tear the globals down by hand so one broken invariant here doesn't leave a live tx index
diff --git a/src/test/i2p_tests.cpp b/src/test/i2p_tests.cpp
index b21539a5394d..bb75348ed77d 100644
--- a/src/test/i2p_tests.cpp
+++ b/src/test/i2p_tests.cpp
@@ -2,6 +2,8 @@
 // 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 <common/system.h>
 #include <i2p.h>
 #include <logging.h>
 #include <netaddress.h>
@@ -10,7 +12,6 @@
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <util/readwritefile.h>
-#include <util/system.h>
 #include <util/threadinterrupt.h>
 
 #include <boost/test/unit_test.hpp>
@@ -22,7 +23,7 @@
 class EnvTestingSetup : public BasicTestingSetup
 {
 public:
-    explicit EnvTestingSetup(const std::string& chainType = CBaseChainParams::MAIN,
+    explicit EnvTestingSetup(const ChainType chainType = ChainType::MAIN,
                              const std::vector<const char*>& extra_args = {})
         : BasicTestingSetup{chainType, extra_args},
           m_prev_log_level{LogInstance().LogLevel()},
diff --git a/src/test/index_migration_tests.cpp b/src/test/index_migration_tests.cpp
index 0a6c08d54b7f..bcf9250b50d5 100644
--- a/src/test/index_migration_tests.cpp
+++ b/src/test/index_migration_tests.cpp
@@ -3,12 +3,12 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <coins.h>
+#include <common/system.h>
 #include <index/timestampindex.h>
 #include <interfaces/chain.h>
 #include <node/blockstorage.h>
 #include <test/util/setup_common.h>
 #include <txdb.h>
-#include <util/system.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
@@ -16,7 +16,7 @@
 namespace {
 struct IndexMigrationSetup : public TestChainSetup {
     IndexMigrationSetup() :
-        TestChainSetup{100, CBaseChainParams::REGTEST, {"-timestampindex=1"}}
+        TestChainSetup{100, ChainType::REGTEST, {"-timestampindex=1"}}
     {
     }
 
diff --git a/src/test/interfaces_tests.cpp b/src/test/interfaces_tests.cpp
index d4533e4b245a..2bdca0b6f459 100644
--- a/src/test/interfaces_tests.cpp
+++ b/src/test/interfaces_tests.cpp
@@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE(providerTxCapabilities)
 
 struct IPv4OptionalChainSetup : public TestChain100Setup {
     IPv4OptionalChainSetup()
-        : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=ipv4_optional@1"}} {}
+        : TestChain100Setup{ChainType::REGTEST, {"-testactivationheight=ipv4_optional@1"}} {}
 };
 
 BOOST_FIXTURE_TEST_CASE(providerTxCapabilitiesIPv4Optional, IPv4OptionalChainSetup)
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index 9d1b41f78a65..ba4208ad1f28 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -12,6 +12,7 @@
 #include <script/script.h>
 #include <test/util/json.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <util/strencodings.h>
 
 #include <boost/test/unit_test.hpp>
@@ -26,7 +27,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
     UniValue tests = read_json(std::string(json_tests::key_io_valid, json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
     CKey privkey;
     CTxDestination destination;
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         const UniValue& test = tests[idx];
@@ -39,7 +40,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
         const std::vector<std::byte> exp_payload{ParseHex<std::byte>(test[1].get_str())};
         const UniValue &metadata = test[2].get_obj();
         bool isPrivkey = metadata.find_value("isPrivkey").get_bool();
-        SelectParams(metadata.find_value("chain").get_str());
+        SelectParams(ChainTypeFromString(metadata.find_value("chain").get_str()).value());
         bool try_case_flip = metadata.find_value("tryCaseFlip").isNull() ? false : metadata.find_value("tryCaseFlip").get_bool();
         if (isPrivkey) {
             bool isCompressed = metadata.find_value("isCompressed").get_bool();
@@ -98,7 +99,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_gen)
         std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
         const UniValue &metadata = test[2].get_obj();
         bool isPrivkey = metadata.find_value("isPrivkey").get_bool();
-        SelectParams(metadata.find_value("chain").get_str());
+        SelectParams(ChainTypeFromString(metadata.find_value("chain").get_str()).value());
         if (isPrivkey) {
             bool isCompressed = metadata.find_value("isCompressed").get_bool();
             CKey key;
@@ -115,7 +116,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_gen)
         }
     }
 
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 
@@ -137,7 +138,7 @@ BOOST_AUTO_TEST_CASE(key_io_invalid)
         std::string exp_base58string = test[0].get_str();
 
         // must be invalid as public and as private key
-        for (const auto& chain : { CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::REGTEST }) {
+        for (const auto& chain : {ChainType::MAIN, ChainType::TESTNET, ChainType::REGTEST}) {
             SelectParams(chain);
             destination = DecodeDestination(exp_base58string);
             BOOST_CHECK_MESSAGE(!IsValidDestination(destination), "IsValid pubkey in mainnet:" + strTest);
@@ -153,19 +154,19 @@ BOOST_AUTO_TEST_CASE(dip18_platform_roundtrip)
     struct Sample {
         std::string hash_hex;
         std::string address;
-        std::string chain;
+        ChainType chain;
         bool is_p2sh;
     };
     // Samples from DIP-0018 (Test Vectors section).
     const Sample samples[] = {
-        {"f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525", "dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs",  CBaseChainParams::MAIN, false},
-        {"a5ff0046217fd1c7d238e3e146cc5bfd90832a7e", "dash1kzjl7qzxy9lar37j8r37z3kvt07epqe20ckxfezw",  CBaseChainParams::MAIN, false},
-        {"6d92674fd64472a3dfcfc3ebcfed7382bf699d7b", "dash1kpkeye606ez89g7lelp7hnldwwpt76va0v3j6x28",  CBaseChainParams::MAIN, false},
-        {"f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525", "tdash1krma5z3ttj75la4m93xcndna9ullamq9y5fzq2j7", CBaseChainParams::TESTNET, false},
-        {"a5ff0046217fd1c7d238e3e146cc5bfd90832a7e", "tdash1kzjl7qzxy9lar37j8r37z3kvt07epqe20cxp68nq", CBaseChainParams::TESTNET, false},
-        {"6d92674fd64472a3dfcfc3ebcfed7382bf699d7b", "tdash1kpkeye606ez89g7lelp7hnldwwpt76va0vp4fcmf", CBaseChainParams::TESTNET, false},
-        {"43fa183cf3fb6e9e7dc62b692aeb4fc8d8045636", "dash1sppl5xpu70aka8nacc4kj2htflydspzkxch4cad6",  CBaseChainParams::MAIN, true},
-        {"43fa183cf3fb6e9e7dc62b692aeb4fc8d8045636", "tdash1sppl5xpu70aka8nacc4kj2htflydspzkxc8jtru5", CBaseChainParams::TESTNET, true},
+        {"f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525", "dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs",  ChainType::MAIN, false},
+        {"a5ff0046217fd1c7d238e3e146cc5bfd90832a7e", "dash1kzjl7qzxy9lar37j8r37z3kvt07epqe20ckxfezw",  ChainType::MAIN, false},
+        {"6d92674fd64472a3dfcfc3ebcfed7382bf699d7b", "dash1kpkeye606ez89g7lelp7hnldwwpt76va0v3j6x28",  ChainType::MAIN, false},
+        {"f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525", "tdash1krma5z3ttj75la4m93xcndna9ullamq9y5fzq2j7", ChainType::TESTNET, false},
+        {"a5ff0046217fd1c7d238e3e146cc5bfd90832a7e", "tdash1kzjl7qzxy9lar37j8r37z3kvt07epqe20cxp68nq", ChainType::TESTNET, false},
+        {"6d92674fd64472a3dfcfc3ebcfed7382bf699d7b", "tdash1kpkeye606ez89g7lelp7hnldwwpt76va0vp4fcmf", ChainType::TESTNET, false},
+        {"43fa183cf3fb6e9e7dc62b692aeb4fc8d8045636", "dash1sppl5xpu70aka8nacc4kj2htflydspzkxch4cad6",  ChainType::MAIN, true},
+        {"43fa183cf3fb6e9e7dc62b692aeb4fc8d8045636", "tdash1sppl5xpu70aka8nacc4kj2htflydspzkxc8jtru5", ChainType::TESTNET, true},
     };
     for (const auto& s : samples) {
         SelectParams(s.chain);
@@ -186,12 +187,12 @@ BOOST_AUTO_TEST_CASE(dip18_platform_roundtrip)
         BOOST_CHECK_EQUAL(HexStr(got_hash), std::string(s.hash_hex));
         BOOST_CHECK_EQUAL(EncodePlatformDestination(dest), std::string(s.address));
     }
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 BOOST_AUTO_TEST_CASE(dip18_platform_invalid)
 {
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
     std::string err;
 
     // Wrong HRP for the selected network (testnet string on mainnet).
@@ -238,11 +239,11 @@ BOOST_AUTO_TEST_CASE(dip18_platform_invalid)
     BOOST_CHECK(!IsValidPlatformDestination(DecodePlatformDestination("not-an-address", err)));
 
     // Mainnet address on testnet must fail.
-    SelectParams(CBaseChainParams::TESTNET);
+    SelectParams(ChainType::TESTNET);
     BOOST_CHECK(!IsValidPlatformDestination(
         DecodePlatformDestination("dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs", err)));
 
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index 007a94def8c4..cc54589b3793 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -4,6 +4,7 @@
 
 #include <key.h>
 
+#include <common/system.h>
 #include <key_io.h>
 #include <streams.h>
 #include <test/util/random.h>
@@ -11,7 +12,6 @@
 #include <uint256.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 
 #include <string>
 #include <vector>
diff --git a/src/test/llmq_chainlock_tests.cpp b/src/test/llmq_chainlock_tests.cpp
index e3aed1100e00..253dd677a53f 100644
--- a/src/test/llmq_chainlock_tests.cpp
+++ b/src/test/llmq_chainlock_tests.cpp
@@ -107,7 +107,7 @@ BOOST_FIXTURE_TEST_CASE(historical_coinbase_lookup_from_disk, RegTestingSetup)
         }
         chain.SetTip(index);
     }
-    chainlock::CoinbaseChainLockReader reader(chain.Tip());
+    chainlock::CoinbaseChainLockReader reader(chain.Tip(), m_node.chainman->m_blockman);
     BOOST_CHECK(!reader.Read(activation + 2));
     BOOST_CHECK(!reader.Find(-1, activation + 128));
     BOOST_CHECK(!reader.Find(activation + 128, activation + 128));
@@ -132,14 +132,14 @@ BOOST_FIXTURE_TEST_CASE(historical_coinbase_lookup_from_disk, RegTestingSetup)
     }
     // A repeated certificate spanning more than the request's disk-read budget
     // must still allow finding the next certificate (or reporting its absence).
-    chainlock::CoinbaseChainLockReader long_gap(chain.Tip());
+    chainlock::CoinbaseChainLockReader long_gap(chain.Tip(), m_node.chainman->m_blockman);
     const auto late = long_gap.Find(activation + 100, activation + 16999);
     BOOST_REQUIRE(late);
     BOOST_CHECK_EQUAL(late->carrier->nHeight, activation + 17000);
     BOOST_CHECK_EQUAL(late->height, activation + 16999);
     BOOST_CHECK(!long_gap.Find(activation + 100, activation + 16998));
     // A new request on a shorter chain must not reuse the old request's cache.
-    chainlock::CoinbaseChainLockReader after_disconnect(chain[activation + 66]);
+    chainlock::CoinbaseChainLockReader after_disconnect(chain[activation + 66], m_node.chainman->m_blockman);
     BOOST_CHECK(!after_disconnect.Find(activation + 65, activation + 65));
     BOOST_REQUIRE(after_disconnect.Find(activation + 1, activation + 1));
 
@@ -148,27 +148,27 @@ BOOST_FIXTURE_TEST_CASE(historical_coinbase_lookup_from_disk, RegTestingSetup)
     chainlock::ClearCoinbaseChainLockCacheForTesting();
     const bool scheme = bls::bls_legacy_scheme.load();
     bls::bls_legacy_scheme.store(!scheme);
-    const auto under_other = chainlock::CoinbaseChainLockReader(chain.Tip()).Read(activation + 40);
+    const auto under_other = chainlock::CoinbaseChainLockReader(chain.Tip(), m_node.chainman->m_blockman).Read(activation + 40);
     bls::bls_legacy_scheme.store(scheme);
     BOOST_REQUIRE(under_other);
     BOOST_CHECK_EQUAL(under_other->height, activation + 1);
-    const auto after = chainlock::CoinbaseChainLockReader(chain.Tip()).Read(activation + 40);
+    const auto after = chainlock::CoinbaseChainLockReader(chain.Tip(), m_node.chainman->m_blockman).Read(activation + 40);
     BOOST_REQUIRE(after);
     BOOST_CHECK(after->Signed().getSig() == signature);
     BOOST_CHECK_EQUAL(after->height, activation + 1);
 
     // A carrier's certificate is a fact about its block hash, so once read it is
     // served from the process-wide memo even if the block data goes away...
-    BOOST_REQUIRE(chainlock::CoinbaseChainLockReader(chain.Tip()).Read(activation + 30));
+    BOOST_REQUIRE(chainlock::CoinbaseChainLockReader(chain.Tip(), m_node.chainman->m_blockman).Read(activation + 30));
     WITH_LOCK(cs_main, indexes[activation + 30].nStatus &= ~BLOCK_HAVE_DATA);
-    const auto memoized = chainlock::CoinbaseChainLockReader(chain.Tip()).Read(activation + 30);
+    const auto memoized = chainlock::CoinbaseChainLockReader(chain.Tip(), m_node.chainman->m_blockman).Read(activation + 30);
     BOOST_REQUIRE(memoized);
     BOOST_CHECK(memoized->Signed().getSig() == signature);
 
     // ...while unavailable block data that was never read is an error, distinct
     // from an absent certificate.
     chainlock::ClearCoinbaseChainLockCacheForTesting();
-    chainlock::CoinbaseChainLockReader unavailable(chain.Tip());
+    chainlock::CoinbaseChainLockReader unavailable(chain.Tip(), m_node.chainman->m_blockman);
     BOOST_CHECK_THROW(unavailable.Read(activation + 30), std::runtime_error);
 }
 
diff --git a/src/test/llmq_params_tests.cpp b/src/test/llmq_params_tests.cpp
index c7bdd2481ea1..fda9c6fdf58e 100644
--- a/src/test/llmq_params_tests.cpp
+++ b/src/test/llmq_params_tests.cpp
@@ -2,14 +2,15 @@
 // 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 <test/util/llmq_tests.h>
 #include <test/util/setup_common.h>
 
 #include <chainparams.h>
 #include <chainparamsbase.h>
+#include <common/system.h>
 #include <consensus/params.h>
 #include <llmq/params.h>
-#include <util/system.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -184,7 +185,7 @@ BOOST_AUTO_TEST_CASE(llmq_params_calculations_overflow_test)
 }
 
 //! Build chain params for `chain` with a single LLMQ size/threshold override applied.
-static std::unique_ptr<const CChainParams> ChainParamsWithLLMQOverride(const std::string& chain,
+static std::unique_ptr<const CChainParams> ChainParamsWithLLMQOverride(const ChainType chain,
                                                                        const std::string& arg,
                                                                        int size, int threshold)
 {
@@ -216,26 +217,26 @@ BOOST_AUTO_TEST_CASE(llmq_params_size_override_bounds_test)
 
     for (const auto& [arg, type] : regtest_overrides) {
         // Normal custom values keep working
-        const auto small = ChainParamsWithLLMQOverride(CBaseChainParams::REGTEST, arg, 5, 3);
+        const auto small = ChainParamsWithLLMQOverride(ChainType::REGTEST, arg, 5, 3);
         BOOST_CHECK_EQUAL(LLMQSize(*small, type), 5);
 
         // Exactly the maximum is accepted
-        const auto at_max = ChainParamsWithLLMQOverride(CBaseChainParams::REGTEST, arg, kMax, kMax * 2 / 3);
+        const auto at_max = ChainParamsWithLLMQOverride(ChainType::REGTEST, arg, kMax, kMax * 2 / 3);
         BOOST_CHECK_EQUAL(LLMQSize(*at_max, type), kMax);
 
         // One above the maximum is rejected
-        BOOST_CHECK_THROW(ChainParamsWithLLMQOverride(CBaseChainParams::REGTEST, arg, kMax + 1, kMax * 2 / 3),
+        BOOST_CHECK_THROW(ChainParamsWithLLMQOverride(ChainType::REGTEST, arg, kMax + 1, kMax * 2 / 3),
                           std::runtime_error);
     }
 
     // Same bounds for the devnet override
-    const auto devnet_small = ChainParamsWithLLMQOverride(CBaseChainParams::DEVNET, "-llmqdevnetparams", 12, 6);
+    const auto devnet_small = ChainParamsWithLLMQOverride(ChainType::DEVNET, "-llmqdevnetparams", 12, 6);
     BOOST_CHECK_EQUAL(LLMQSize(*devnet_small, LLMQType::LLMQ_DEVNET), 12);
 
-    const auto devnet_at_max = ChainParamsWithLLMQOverride(CBaseChainParams::DEVNET, "-llmqdevnetparams", kMax, kMax / 2);
+    const auto devnet_at_max = ChainParamsWithLLMQOverride(ChainType::DEVNET, "-llmqdevnetparams", kMax, kMax / 2);
     BOOST_CHECK_EQUAL(LLMQSize(*devnet_at_max, LLMQType::LLMQ_DEVNET), kMax);
 
-    BOOST_CHECK_THROW(ChainParamsWithLLMQOverride(CBaseChainParams::DEVNET, "-llmqdevnetparams", kMax + 1, kMax / 2),
+    BOOST_CHECK_THROW(ChainParamsWithLLMQOverride(ChainType::DEVNET, "-llmqdevnetparams", kMax + 1, kMax / 2),
                       std::runtime_error);
 }
 
diff --git a/src/test/llmq_qgetdata_tests.cpp b/src/test/llmq_qgetdata_tests.cpp
index 99cb472f6366..65a0527c30d2 100644
--- a/src/test/llmq_qgetdata_tests.cpp
+++ b/src/test/llmq_qgetdata_tests.cpp
@@ -45,7 +45,7 @@ struct QGetDataSetup : public TestingSetup {
     std::unique_ptr<NetQuorum> m_net_quorum;
 
     QGetDataSetup() :
-        TestingSetup{CBaseChainParams::REGTEST},
+        TestingSetup{ChainType::REGTEST},
         m_role{*m_node.llmq_ctx->qman}
     {
         BOOST_REQUIRE(m_node.connman);
diff --git a/src/test/masternode_params_tests.cpp b/src/test/masternode_params_tests.cpp
index f3ba661a6d51..8f8f7c05472c 100644
--- a/src/test/masternode_params_tests.cpp
+++ b/src/test/masternode_params_tests.cpp
@@ -3,9 +3,10 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <kernel/mempool_options.h>
 #include <node/mempool_args.h>
-#include <util/system.h>
 
 #include <test/util/setup_common.h>
 
diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index c936eabcdbeb..11fd977351fc 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -2,10 +2,10 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <policy/policy.h>
 #include <test/util/txmempool.h>
 #include <txmempool.h>
-#include <util/system.h>
 #include <util/time.h>
 
 #include <test/util/setup_common.h>
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 0b6d6f37050c..96e6e2d13d08 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -2,6 +2,8 @@
 // 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 <common/system.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
@@ -14,7 +16,6 @@
 #include <timedata.h>
 #include <uint256.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 #include <versionbits.h>
diff --git a/src/test/net_peer_connection_tests.cpp b/src/test/net_peer_connection_tests.cpp
index 9c1ed911a87b..2295f75b3d2f 100644
--- a/src/test/net_peer_connection_tests.cpp
+++ b/src/test/net_peer_connection_tests.cpp
@@ -30,7 +30,7 @@
 
 struct LogIPsTestingSetup : public TestingSetup {
     LogIPsTestingSetup()
-        : TestingSetup{CBaseChainParams::MAIN, /*extra_args=*/{"-logips"}} {}
+        : TestingSetup{ChainType::MAIN, /*extra_args=*/{"-logips"}} {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(net_peer_connection_tests, LogIPsTestingSetup)
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index c6f86427dabf..91fa78c70d21 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -7,6 +7,7 @@
 #include <arith_uint256.h>
 #include <chainparams.h>
 #include <clientversion.h>
+#include <common/args.h>
 #include <compat/compat.h>
 #include <key.h>
 #include <net.h>
@@ -24,7 +25,6 @@
 #include <timedata.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <validation.h>
 #include <version.h>
 
@@ -1952,7 +1952,7 @@ BOOST_AUTO_TEST_CASE(v2transport_test)
     // Send wrong network's V1 header
     {
         V2TransportTester tester(false);
-        tester.SendV1Version(CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->MessageStart());
+        tester.SendV1Version(CreateChainParams(*m_node.args, ChainType::MAIN)->MessageStart());
         auto ret = tester.Interact();
         BOOST_CHECK(!ret);
     }
diff --git a/src/test/pow_tests.cpp b/src/test/pow_tests.cpp
index 60367bb69025..95bfe1b4ee98 100644
--- a/src/test/pow_tests.cpp
+++ b/src/test/pow_tests.cpp
@@ -7,6 +7,7 @@
 #include <pow.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -15,7 +16,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 /* Test calculation of next difficulty target with DGW */
 BOOST_AUTO_TEST_CASE(get_next_work)
 {
-    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
 
     static const std::vector<std::pair<uint32_t, uint32_t>> mainnet_data = {
         { 1408728124, 0x1b104be1U }, { 1408728332, 0x1b10e09eU }, { 1408728479, 0x1b11a33cU },
@@ -47,7 +48,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
     BOOST_CHECK_EQUAL(GetNextWorkRequired(blockIndexLast, &blockHeader, chainParams->GetConsensus()), 0x1b1441deU); // Block #123457 has 0x1b1441de
 
     // test special rules for slow blocks on devnet/testnet
-    const auto chainParamsDev = CreateChainParams(*m_node.args, CBaseChainParams::DEVNET);
+    const auto chainParamsDev = CreateChainParams(*m_node.args, ChainType::DEVNET);
 
     // make sure normal rules apply
     blockHeader.nTime = 1408732505; // Block #123457
@@ -68,7 +69,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
 /* Test the constraint on the upper bound for next work */
 // BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
 // {
-//     const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
+//     const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
 
 //     int64_t nLastRetargetTime = 1231006505; // Block #0
 //     CBlockIndex pindexLast;
@@ -81,7 +82,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
 /* Test the constraint on the lower bound for actual time taken */
 // BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
 // {
-//     const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
+//     const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
 
 //     int64_t nLastRetargetTime = 1279008237; // Block #66528
 //     CBlockIndex pindexLast;
@@ -94,7 +95,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
 /* Test the constraint on the upper bound for actual time taken */
 // BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
 // {
-//     const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
+//     const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
 
 //     int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
 //     CBlockIndex pindexLast;
@@ -106,7 +107,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)
 {
-    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, ChainType::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     nBits = UintToArith256(consensus.powLimit).GetCompact(true);
@@ -116,7 +117,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)
 {
-    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, ChainType::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits{~0x00800000U};
     hash.SetHex("0x1");
@@ -125,7 +126,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)
 {
-    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, ChainType::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     arith_uint256 nBits_arith = UintToArith256(consensus.powLimit);
@@ -137,7 +138,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_biger_hash_than_target)
 {
-    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, ChainType::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     arith_uint256 hash_arith = UintToArith256(consensus.powLimit);
@@ -149,7 +150,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_biger_hash_than_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_zero_target)
 {
-    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, ChainType::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     arith_uint256 hash_arith{0};
@@ -160,7 +161,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_zero_target)
 
 BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
 {
-    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
     std::vector<CBlockIndex> blocks(10000);
     for (int i = 0; i < 10000; i++) {
         blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
@@ -180,9 +181,9 @@ BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
     }
 }
 
-void sanity_check_chainparams(const ArgsManager& args, std::string chainName)
+void sanity_check_chainparams(const ArgsManager& args, ChainType chain_type)
 {
-    const auto chainParams = CreateChainParams(args, chainName);
+    const auto chainParams = CreateChainParams(args, chain_type);
     const auto consensus = chainParams->GetConsensus();
 
     // hash genesis is correct
@@ -205,7 +206,7 @@ void sanity_check_chainparams(const ArgsManager& args, std::string chainName)
         targ_max /= consensus.nPowTargetTimespan*4;
         // for devnets pow-no-retargeting may work as non-expected but it's a breaking change to fix it
         // TODO: remove this special case for devnet
-        if (chainName != CBaseChainParams::DEVNET) {
+        if (chain_type != ChainType::DEVNET) {
             BOOST_CHECK(UintToArith256(consensus.powLimit) < targ_max);
         }
     }
@@ -213,23 +214,23 @@ void sanity_check_chainparams(const ArgsManager& args, std::string chainName)
 
 BOOST_AUTO_TEST_CASE(ChainParams_MAIN_sanity)
 {
-    sanity_check_chainparams(*m_node.args, CBaseChainParams::MAIN);
+    sanity_check_chainparams(*m_node.args, ChainType::MAIN);
 }
 
 BOOST_AUTO_TEST_CASE(ChainParams_REGTEST_sanity)
 {
-    sanity_check_chainparams(*m_node.args, CBaseChainParams::REGTEST);
+    sanity_check_chainparams(*m_node.args, ChainType::REGTEST);
 }
 
 BOOST_AUTO_TEST_CASE(ChainParams_TESTNET_sanity)
 {
-    sanity_check_chainparams(*m_node.args, CBaseChainParams::TESTNET);
+    sanity_check_chainparams(*m_node.args, ChainType::TESTNET);
 }
 
 BOOST_AUTO_TEST_CASE(ChainParams_DEVNET_sanity)
 {
     gArgs.SoftSetBoolArg("-devnet", true);
-    sanity_check_chainparams(*m_node.args, CBaseChainParams::DEVNET);
+    sanity_check_chainparams(*m_node.args, ChainType::DEVNET);
     gArgs.ForceRemoveArg("devnet");
 }
 
diff --git a/src/test/quorum_proofs_tests.cpp b/src/test/quorum_proofs_tests.cpp
index d4be48ac691b..5b3993fc5d1c 100644
--- a/src/test/quorum_proofs_tests.cpp
+++ b/src/test/quorum_proofs_tests.cpp
@@ -99,7 +99,7 @@ static const char* TESTNET_PROOF =
     "3ad9678edcd1ff85bb3f2581b8d54d57685615"
 ;
 struct QuorumProofsRegtestSetup : BasicTestingSetup {
-    QuorumProofsRegtestSetup() : BasicTestingSetup(CBaseChainParams::REGTEST) {}
+    QuorumProofsRegtestSetup() : BasicTestingSetup(ChainType::REGTEST) {}
 };
 
 // Use a single active quorum to deterministically exercise retirement at a
@@ -116,7 +116,7 @@ struct QuorumProofGenerationSetup : TestingSetup {
     std::vector<CBLSSecretKey> keys;
 
     QuorumProofGenerationSetup() :
-        TestingSetup(CBaseChainParams::TESTNET),
+        TestingSetup(ChainType::TESTNET),
         saved_consensus(Params().GetConsensus()),
         saved_tip(WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()))
     {
@@ -326,7 +326,7 @@ BOOST_FIXTURE_TEST_CASE(generation_retries_retired_checkpoint_signer, QuorumProo
     CreateHistory();
     auto& chain = *WITH_LOCK(cs_main, return &m_node.chainman->ActiveChain());
     const auto* checkpoint = chain[checkpoint_height];
-    chainlock::CoinbaseChainLockReader reader(chain.Tip());
+    chainlock::CoinbaseChainLockReader reader(chain.Tip(), m_node.chainman->m_blockman);
     llmq::QuorumProofBuilder builder(*m_node.llmq_ctx->quorum_block_processor, *m_node.llmq_ctx->qman, chain.Tip(),
                                      *m_node.chainman, reader);
     const auto first = reader.Find(checkpoint_height + 1, chain.Height());
@@ -336,7 +336,7 @@ BOOST_FIXTURE_TEST_CASE(generation_retries_retired_checkpoint_signer, QuorumProo
 
     const auto result = Generate(checkpoint_height + 1);
     const auto proof = llmq::QuorumProofChain::Decode(ParseHex(result["proof_hex"].get_str()));
-    BOOST_CHECK_EQUAL(proof.Verify(llmq::QuorumProofBuilder::StateAt(checkpoint)).height,
+    BOOST_CHECK_EQUAL(proof.Verify(llmq::QuorumProofBuilder::StateAt(m_node.chainman->m_blockman, checkpoint)).height,
                       checkpoint_height + llmq::SIGN_HEIGHT_OFFSET);
     BOOST_CHECK(proof.links.empty());
 
@@ -417,7 +417,7 @@ BOOST_FIXTURE_TEST_CASE(consensus_valid_envelopes_are_provable, QuorumProofGener
     BOOST_CHECK_GT(contested_selections, 0);
     auto& chain = *WITH_LOCK(cs_main, return &m_node.chainman->ActiveChain());
     const auto* checkpoint = chain[checkpoint_height];
-    chainlock::CoinbaseChainLockReader reader(chain.Tip());
+    chainlock::CoinbaseChainLockReader reader(chain.Tip(), m_node.chainman->m_blockman);
     llmq::QuorumProofBuilder builder(*m_node.llmq_ctx->quorum_block_processor, *m_node.llmq_ctx->qman, chain.Tip(),
                                      *m_node.chainman, reader);
     const auto entry = reader.Find(handoff_height + llmq::SIGN_HEIGHT_OFFSET, chain.Height());
@@ -436,12 +436,12 @@ BOOST_FIXTURE_TEST_CASE(consensus_valid_envelopes_are_provable, QuorumProofGener
     BOOST_CHECK(!mining.vin.empty());
     BOOST_CHECK(!mining.vout.empty());
 
-    const auto state = proof->Verify(llmq::QuorumProofBuilder::StateAt(checkpoint));
+    const auto state = proof->Verify(llmq::QuorumProofBuilder::StateAt(m_node.chainman->m_blockman, checkpoint));
     BOOST_CHECK_EQUAL(state.height, uint32_t(entry->height));
 
     // The RPC reuses the target block's own state instead of re-verifying the
     // proof; Build() only returns a proof whose verified state is exactly that.
-    BOOST_CHECK(state == llmq::QuorumProofBuilder::StateAt(chain[state.height]));
+    BOOST_CHECK(state == llmq::QuorumProofBuilder::StateAt(m_node.chainman->m_blockman, chain[state.height]));
 
     // The memoized active set is the committed set: its leaves are sorted and
     // hash to the block's own quorum root.
@@ -450,7 +450,7 @@ BOOST_FIXTURE_TEST_CASE(consensus_valid_envelopes_are_provable, QuorumProofGener
     for (const auto& commitment : active)
         active_leaves.push_back(::SerializeHash(commitment));
     BOOST_CHECK(std::is_sorted(active_leaves.begin(), active_leaves.end()));
-    BOOST_CHECK(ComputeMerkleRoot(active_leaves) == llmq::QuorumProofBuilder::StateAt(checkpoint).quorumRoot);
+    BOOST_CHECK(ComputeMerkleRoot(active_leaves) == llmq::QuorumProofBuilder::StateAt(m_node.chainman->m_blockman, checkpoint).quorumRoot);
 
     // Encoding with the caller's verified state is byte-identical to verifying again,
     // and a state that is not the proof's own target is refused.
diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 835bd1204caf..8d1bf52e001a 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -42,7 +42,7 @@ class RPCTestingSetup : public TestingSetup
 {
 public:
     RPCTestingSetup()
-        : TestingSetup(CBaseChainParams::MAIN, {"-deprecatedrpc=legacy_mn"}) {}
+        : TestingSetup(ChainType::MAIN, {"-deprecatedrpc=legacy_mn"}) {}
 
     UniValue TransformParams(const UniValue& params, std::vector<std::pair<std::string, bool>> arg_names);
     UniValue CallRPC(std::string args);
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 63d73290516d..1afb5e3d053b 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -8,6 +8,7 @@
 
 #include <test/data/script_tests.json.h>
 
+#include <common/system.h>
 #include <core_io.h>
 #include <key.h>
 #include <rpc/util.h>
diff --git a/src/test/settings_tests.cpp b/src/test/settings_tests.cpp
index 23427c610882..41190b357985 100644
--- a/src/test/settings_tests.cpp
+++ b/src/test/settings_tests.cpp
@@ -2,18 +2,18 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/settings.h>
+#include <common/settings.h>
 
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
-#include <util/fs.h>
-
 
 #include <boost/test/unit_test.hpp>
+#include <common/args.h>
 #include <univalue.h>
+#include <util/chaintype.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 
 #include <fstream>
 #include <map>
@@ -21,20 +21,20 @@
 #include <system_error>
 #include <vector>
 
-inline bool operator==(const util::SettingsValue& a, const util::SettingsValue& b)
+inline bool operator==(const common::SettingsValue& a, const common::SettingsValue& b)
 {
     return a.write() == b.write();
 }
 
-inline std::ostream& operator<<(std::ostream& os, const util::SettingsValue& value)
+inline std::ostream& operator<<(std::ostream& os, const common::SettingsValue& value)
 {
     os << value.write();
     return os;
 }
 
-inline std::ostream& operator<<(std::ostream& os, const std::pair<std::string, util::SettingsValue>& kv)
+inline std::ostream& operator<<(std::ostream& os, const std::pair<std::string, common::SettingsValue>& kv)
 {
-    util::SettingsValue out(util::SettingsValue::VOBJ);
+    common::SettingsValue out(common::SettingsValue::VOBJ);
     out.pushKVEnd(kv.first, kv.second);
     os << out.write();
     return os;
@@ -60,7 +60,7 @@ BOOST_AUTO_TEST_CASE(ReadWrite)
         "null": null
     })");
 
-    std::map<std::string, util::SettingsValue> expected{
+    std::map<std::string, common::SettingsValue> expected{
         {"string", "string"},
         {"num", 5},
         {"bool", true},
@@ -68,15 +68,15 @@ BOOST_AUTO_TEST_CASE(ReadWrite)
     };
 
     // Check file read.
-    std::map<std::string, util::SettingsValue> values;
+    std::map<std::string, common::SettingsValue> values;
     std::vector<std::string> errors;
-    BOOST_CHECK(util::ReadSettings(path, values, errors));
+    BOOST_CHECK(common::ReadSettings(path, values, errors));
     BOOST_CHECK_EQUAL_COLLECTIONS(values.begin(), values.end(), expected.begin(), expected.end());
     BOOST_CHECK(errors.empty());
 
     // Check no errors if file doesn't exist.
     fs::remove(path);
-    BOOST_CHECK(util::ReadSettings(path, values, errors));
+    BOOST_CHECK(common::ReadSettings(path, values, errors));
     BOOST_CHECK(values.empty());
     BOOST_CHECK(errors.empty());
 
@@ -85,20 +85,20 @@ BOOST_AUTO_TEST_CASE(ReadWrite)
         "dupe": "string",
         "dupe": "dupe"
     })");
-    BOOST_CHECK(!util::ReadSettings(path, values, errors));
+    BOOST_CHECK(!common::ReadSettings(path, values, errors));
     std::vector<std::string> dup_keys = {strprintf("Found duplicate key dupe in settings file %s", fs::PathToString(path))};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(), dup_keys.begin(), dup_keys.end());
     BOOST_CHECK(values.empty());
 
     // Check non-kv json files not allowed
     WriteText(path, R"("non-kv")");
-    BOOST_CHECK(!util::ReadSettings(path, values, errors));
+    BOOST_CHECK(!common::ReadSettings(path, values, errors));
     std::vector<std::string> non_kv = {strprintf("Found non-object value \"non-kv\" in settings file %s", fs::PathToString(path))};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(), non_kv.begin(), non_kv.end());
 
     // Check invalid json not allowed
     WriteText(path, R"(invalid json)");
-    BOOST_CHECK(!util::ReadSettings(path, values, errors));
+    BOOST_CHECK(!common::ReadSettings(path, values, errors));
     std::vector<std::string> fail_parse = {strprintf("Settings file %s does not contain valid JSON. This is probably caused by disk corruption or a crash, "
                                                      "and can be fixed by removing the file, which will reset settings to default values.",
                                                      fs::PathToString(path))};
@@ -106,10 +106,10 @@ BOOST_AUTO_TEST_CASE(ReadWrite)
 }
 
 //! Check settings struct contents against expected json strings.
-static void CheckValues(const util::Settings& settings, const std::string& single_val, const std::string& list_val)
+static void CheckValues(const common::Settings& settings, const std::string& single_val, const std::string& list_val)
 {
-    util::SettingsValue single_value = GetSetting(settings, "section", "name", false, false, false);
-    util::SettingsValue list_value(util::SettingsValue::VARR);
+    common::SettingsValue single_value = GetSetting(settings, "section", "name", false, false, false);
+    common::SettingsValue list_value(common::SettingsValue::VARR);
     for (const auto& item : GetSettingsList(settings, "section", "name", false)) {
         list_value.push_back(item);
     }
@@ -120,7 +120,7 @@ static void CheckValues(const util::Settings& settings, const std::string& singl
 // Simple settings merge test case.
 BOOST_AUTO_TEST_CASE(Simple)
 {
-    util::Settings settings;
+    common::Settings settings;
     settings.command_line_options["name"].emplace_back("val1");
     settings.command_line_options["name"].emplace_back("val2");
     settings.ro_config["section"]["name"].emplace_back(2);
@@ -128,7 +128,7 @@ BOOST_AUTO_TEST_CASE(Simple)
     // The last given arg takes precedence when specified via commandline.
     CheckValues(settings, R"("val2")", R"(["val1","val2",2])");
 
-    util::Settings settings2;
+    common::Settings settings2;
     settings2.ro_config["section"]["name"].emplace_back("val2");
     settings2.ro_config["section"]["name"].emplace_back("val3");
 
@@ -142,7 +142,7 @@ BOOST_AUTO_TEST_CASE(Simple)
 // its default value.
 BOOST_AUTO_TEST_CASE(NullOverride)
 {
-    util::Settings settings;
+    common::Settings settings;
     settings.command_line_options["name"].emplace_back("value");
     BOOST_CHECK_EQUAL(R"("value")", GetSetting(settings, "section", "name", false, false, false).write().c_str());
     settings.forced_settings["name"] = {};
@@ -192,16 +192,16 @@ BOOST_FIXTURE_TEST_CASE(Merge, MergeTestingSetup)
         if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed");
     }
 
-    const std::string& network = CBaseChainParams::MAIN;
+    const std::string& network = ChainTypeToString(ChainType::MAIN);
     ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions, bool force_set,
                           bool ignore_default_section_config) {
         std::string desc;
         int value_suffix = 0;
-        util::Settings settings;
+        common::Settings settings;
 
         const std::string& name = ignore_default_section_config ? "wallet" : "server";
         auto push_values = [&](Action action, const char* value_prefix, const std::string& name_prefix,
-                               std::vector<util::SettingsValue>& dest) {
+                               std::vector<common::SettingsValue>& dest) {
             if (action == SET || action == SECTION_SET) {
                 for (int i = 0; i < 2; ++i) {
                     dest.emplace_back(value_prefix + ToString(++value_suffix));
@@ -227,7 +227,7 @@ BOOST_FIXTURE_TEST_CASE(Merge, MergeTestingSetup)
         }
 
         desc += " || ";
-        desc += GetSetting(settings, network, name, ignore_default_section_config, /*ignore_nonpersistent=*/false, /*get_chain_name=*/false).write();
+        desc += GetSetting(settings, network, name, ignore_default_section_config, /*ignore_nonpersistent=*/false, /*get_chain_type=*/false).write();
         desc += " |";
         for (const auto& s : GetSettingsList(settings, network, name, ignore_default_section_config)) {
             desc += " ";
diff --git a/src/test/sighash_tests.cpp b/src/test/sighash_tests.cpp
index 1f7b4502776b..4993ff2fcf89 100644
--- a/src/test/sighash_tests.cpp
+++ b/src/test/sighash_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <consensus/tx_check.h>
 #include <consensus/validation.h>
 #include <hash.h>
diff --git a/src/test/sock_tests.cpp b/src/test/sock_tests.cpp
index a7a49832d566..bddf27eb7fe2 100644
--- a/src/test/sock_tests.cpp
+++ b/src/test/sock_tests.cpp
@@ -2,10 +2,10 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <compat/compat.h>
 #include <test/util/setup_common.h>
 #include <util/sock.h>
-#include <util/system.h>
 #include <util/threadinterrupt.h>
 
 #include <boost/test/unit_test.hpp>
diff --git a/src/test/subsidy_tests.cpp b/src/test/subsidy_tests.cpp
index ed33c6372543..1a28219c7457 100644
--- a/src/test/subsidy_tests.cpp
+++ b/src/test/subsidy_tests.cpp
@@ -13,7 +13,7 @@ BOOST_FIXTURE_TEST_SUITE(subsidy_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(block_subsidy_test)
 {
-    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
 
     uint32_t nPrevBits;
     int32_t nPrevHeight;
diff --git a/src/test/txpackage_tests.cpp b/src/test/txpackage_tests.cpp
index d6429ff2b1ae..3a0af798c8d0 100644
--- a/src/test/txpackage_tests.cpp
+++ b/src/test/txpackage_tests.cpp
@@ -18,7 +18,7 @@
 
 struct TestChain100NoDIP0001Setup : public TestChain100Setup {
     TestChain100NoDIP0001Setup()
-        : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=dip0001@2000"}} {}
+        : TestChain100Setup{ChainType::REGTEST, {"-testactivationheight=dip0001@2000"}} {}
 };
 
 BOOST_AUTO_TEST_SUITE(txpackage_tests)
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index 5941e2a75619..707f2219413f 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -19,12 +19,12 @@
 
 struct TestChain100NoDIP0001Setup : public TestChain100Setup {
     TestChain100NoDIP0001Setup()
-        : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=dip0001@2000"}} {}
+        : TestChain100Setup{ChainType::REGTEST, {"-testactivationheight=dip0001@2000"}} {}
 };
 
 struct TestChain100DIP3Setup : public TestChain100Setup {
     TestChain100DIP3Setup()
-        : TestChain100Setup{CBaseChainParams::REGTEST, {"-dip3params=101:500"}} {}
+        : TestChain100Setup{ChainType::REGTEST, {"-dip3params=101:500"}} {}
 };
 
 
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
index e0f45aea54ba..1b7d8b388e0e 100644
--- a/src/test/txvalidationcache_tests.cpp
+++ b/src/test/txvalidationcache_tests.cpp
@@ -8,13 +8,14 @@
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 struct Dersig100Setup : public TestChain100Setup {
     Dersig100Setup()
-        : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=dersig@102"}} {}
+        : TestChain100Setup{ChainType::REGTEST, {"-testactivationheight=dersig@102"}} {}
 };
 
 bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
diff --git a/src/test/util/blockfilter.cpp b/src/test/util/blockfilter.cpp
index ec703c6a7b73..a806844e3478 100644
--- a/src/test/util/blockfilter.cpp
+++ b/src/test/util/blockfilter.cpp
@@ -8,20 +8,19 @@
 #include <node/blockstorage.h>
 #include <validation.h>
 
-using node::ReadBlockFromDisk;
-using node::UndoReadFromDisk;
+using node::BlockManager;
 
-bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex* block_index, BlockFilter& filter)
+bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex& block_index, BlockFilter& filter, const BlockManager& blockman)
 {
     LOCK(::cs_main);
 
     CBlock block;
-    if (!ReadBlockFromDisk(block, block_index->GetBlockPos(), Params().GetConsensus())) {
+    if (!blockman.ReadBlockFromDisk(block, block_index.GetBlockPos())) {
         return false;
     }
 
     CBlockUndo block_undo;
-    if (block_index->nHeight > 0 && !UndoReadFromDisk(block_undo, block_index)) {
+    if (block_index.nHeight > 0 && !blockman.UndoReadFromDisk(block_undo, block_index)) {
         return false;
     }
 
diff --git a/src/test/util/blockfilter.h b/src/test/util/blockfilter.h
index 7f53c78c1f01..789ce5d3aaed 100644
--- a/src/test/util/blockfilter.h
+++ b/src/test/util/blockfilter.h
@@ -8,7 +8,10 @@
 #include <blockfilter.h>
 
 class CBlockIndex;
+namespace node {
+class BlockManager;
+}
 
-bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex* block_index, BlockFilter& filter);
+bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex& block_index, BlockFilter& filter, const node::BlockManager& blockman);
 
 #endif // BITCOIN_TEST_UTIL_BLOCKFILTER_H
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 6b92d114fa5d..c4e5f965a834 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -15,6 +15,8 @@
 #include <chainlock/chainlock.h>
 #include <chainlock/handler.h>
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/params.h>
@@ -33,6 +35,7 @@
 #include <node/blockstorage.h>
 #include <node/chainstate.h>
 #include <node/context.h>
+#include <node/kernel_notifications.h>
 #include <node/mempool_args.h>
 #include <node/miner.h>
 #include <node/peerman_args.h>
@@ -57,6 +60,7 @@
 #include <timedata.h>
 #include <txdb.h>
 #include <txmempool.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <util/strencodings.h>
 #include <util/string.h>
@@ -103,7 +107,9 @@
 using kernel::ValidationCacheSizes;
 using node::ApplyArgsManOptions;
 using node::BlockAssembler;
+using node::BlockManager;
 using node::CalculateCacheSizes;
+using node::KernelNotifications;
 using node::LoadChainstate;
 using node::NodeContext;
 using node::VerifyLoadedChainstate;
@@ -138,7 +144,7 @@ struct NetworkSetup
 };
 static NetworkSetup g_networksetup_instance;
 
-BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::vector<const char*>& extra_args, bool dash_dbs_in_memory)
+BasicTestingSetup::BasicTestingSetup(const ChainType chainType, const std::vector<const char*>& extra_args, bool dash_dbs_in_memory)
     : m_path_root{fs::temp_directory_path() / "test_common_" PACKAGE_NAME / g_insecure_rand_ctx_temp_path.rand256().ToString()},
       m_args{},
       m_dash_dbs_in_memory{dash_dbs_in_memory}
@@ -173,7 +179,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
             throw std::runtime_error{error};
         }
     }
-    SelectParams(chainName);
+    SelectParams(chainType);
     SeedInsecureRand();
     if (G_TEST_LOG_FUN) LogInstance().PushBackCallback(G_TEST_LOG_FUN);
     InitLogging(*m_node.args);
@@ -254,8 +260,8 @@ BasicTestingSetup::~BasicTestingSetup()
     m_node.args = nullptr;
 }
 
-ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::vector<const char*>& extra_args, bool dash_dbs_in_memory)
-    : BasicTestingSetup(chainName, extra_args, dash_dbs_in_memory)
+ChainTestingSetup::ChainTestingSetup(const ChainType chainType, const std::vector<const char*>& extra_args, bool dash_dbs_in_memory)
+    : BasicTestingSetup(chainType, extra_args, dash_dbs_in_memory)
 {
     const CChainParams& chainparams = Params();
 
@@ -270,14 +276,21 @@ ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::ve
 
     m_cache_sizes = CalculateCacheSizes(m_args);
 
+    m_node.notifications = std::make_unique<KernelNotifications>();
+
     const ChainstateManager::Options chainman_opts{
         .chainparams = chainparams,
         .datadir = m_args.GetDataDirNet(),
         .check_block_index = true,
         .superblock_status = [&sbman = *m_node.sbman](const CDeterministicMNList& mn_list, int height) { return sbman.GetStatus(mn_list, height); },
         .mn_sync = m_node.mn_sync.get(),
+        .notifications = *m_node.notifications,
+    };
+    const BlockManager::Options blockman_opts{
+        .chainparams = chainparams,
+        .blocks_dir = m_args.GetBlocksDirPath(),
     };
-    m_node.chainman = std::make_unique<ChainstateManager>(chainman_opts, node::BlockManager::Options{.chainparams = chainparams});
+    m_node.chainman = std::make_unique<ChainstateManager>(chainman_opts, blockman_opts);
     m_node.chainman->m_blockman.m_block_tree_db = std::make_unique<CBlockTreeDB>(DBParams{
         .path = m_args.GetDataDirNet() / "blocks" / "index",
         .cache_bytes = static_cast<size_t>(m_cache_sizes.block_tree_db),
@@ -400,12 +413,12 @@ void ChainTestingSetup::LoadVerifyActivateChainstate()
 }
 
 TestingSetup::TestingSetup(
-    const std::string& chainName,
+    const ChainType chainType,
     const std::vector<const char*>& extra_args,
     const bool coins_db_in_memory,
     const bool block_tree_db_in_memory,
     const bool dash_dbs_in_memory)
-    : ChainTestingSetup(chainName, extra_args, dash_dbs_in_memory)
+    : ChainTestingSetup(chainType, extra_args, dash_dbs_in_memory)
 {
     m_coins_db_in_memory = coins_db_in_memory;
     m_block_tree_db_in_memory = block_tree_db_in_memory;
@@ -478,23 +491,23 @@ TestingSetup::~TestingSetup()
 }
 
 TestChain100Setup::TestChain100Setup(
-        const std::string& chain_name,
+        const ChainType chain_type,
         const std::vector<const char*>& extra_args,
         const bool coins_db_in_memory,
         const bool block_tree_db_in_memory,
         const bool dash_dbs_in_memory)
-    : TestChainSetup{100, chain_name, extra_args, coins_db_in_memory, block_tree_db_in_memory, dash_dbs_in_memory}
+    : TestChainSetup{100, chain_type, extra_args, coins_db_in_memory, block_tree_db_in_memory, dash_dbs_in_memory}
 {
 }
 
 TestChainSetup::TestChainSetup(
         int num_blocks,
-        const std::string& chain_name,
+        const ChainType chain_type,
         const std::vector<const char*>& extra_args,
         const bool coins_db_in_memory,
         const bool block_tree_db_in_memory,
         const bool dash_dbs_in_memory)
-    : TestingSetup{chain_name, extra_args, coins_db_in_memory, block_tree_db_in_memory, dash_dbs_in_memory}
+    : TestingSetup{chain_type, extra_args, coins_db_in_memory, block_tree_db_in_memory, dash_dbs_in_memory}
 {
     SetMockTime(1598887952);
     constexpr std::array<unsigned char, 32> vchKey = {
@@ -540,7 +553,7 @@ constexpr int V19_ACTIVATION_HEIGHT{109};
 
 TestChainV19BeforeActivationSetup::TestChainV19BeforeActivationSetup() :
     TestChainSetup{V19_ACTIVATION_HEIGHT - 6,
-                   CBaseChainParams::REGTEST,
+                   ChainType::REGTEST,
                    {"-dip3params=100:500", "-testactivationheight=v19@109", "-testactivationheight=v20@109",
                     "-testactivationheight=mn_rr@109"},
                    /*coins_db_in_memory=*/true,
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index ae31029f1e36..67695fbcc775 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -6,7 +6,8 @@
 #ifndef BITCOIN_TEST_UTIL_SETUP_COMMON_H
 #define BITCOIN_TEST_UTIL_SETUP_COMMON_H
 
-#include <chainparamsbase.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <key.h>
 #include <net_processing.h>
 #include <node/caches.h>
@@ -14,10 +15,11 @@
 #include <node/context.h> // IWYU pragma: export
 #include <primitives/transaction.h>
 #include <pubkey.h>
+#include <random.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <util/fs.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <util/vector.h>
 
@@ -63,7 +65,7 @@ std::unique_ptr<PeerManager> MakePeerManager(CConnman& connman,
 struct BasicTestingSetup {
     node::NodeContext m_node; // keep as first member to be destructed last
 
-    explicit BasicTestingSetup(const std::string& chainName = CBaseChainParams::MAIN,
+    explicit BasicTestingSetup(const ChainType chainType = ChainType::MAIN,
                                const std::vector<const char*>& extra_args = {},
                                bool dash_dbs_in_memory = true);
     ~BasicTestingSetup();
@@ -83,7 +85,7 @@ struct ChainTestingSetup : public BasicTestingSetup {
     bool m_coins_db_in_memory{true};
     bool m_block_tree_db_in_memory{true};
 
-    explicit ChainTestingSetup(const std::string& chainName = CBaseChainParams::MAIN,
+    explicit ChainTestingSetup(const ChainType chainType = ChainType::MAIN,
                                const std::vector<const char*>& extra_args = {},
                                bool dash_dbs_in_memory = true);
     ~ChainTestingSetup();
@@ -105,7 +107,7 @@ struct ChainTestingSetup : public BasicTestingSetup {
  */
 struct TestingSetup : public ChainTestingSetup {
     explicit TestingSetup(
-        const std::string& chainName = CBaseChainParams::MAIN,
+        const ChainType chainType = ChainType::MAIN,
         const std::vector<const char*>& extra_args = {},
         const bool coins_db_in_memory = true,
         const bool block_tree_db_in_memory = true,
@@ -116,7 +118,7 @@ struct TestingSetup : public ChainTestingSetup {
 /** Identical to TestingSetup, but chain set to regtest */
 struct RegTestingSetup : public TestingSetup {
     RegTestingSetup(const std::vector<const char*>& extra_args = {})
-        : TestingSetup{CBaseChainParams::REGTEST, extra_args} {}
+        : TestingSetup{ChainType::REGTEST, extra_args} {}
 };
 
 class CBlock;
@@ -126,7 +128,7 @@ class CScript;
 struct TestChainSetup : public TestingSetup
 {
     TestChainSetup(int num_blocks,
-                   const std::string& chain_name = CBaseChainParams::REGTEST,
+                   const ChainType chain_type = ChainType::REGTEST,
                    const std::vector<const char*>& extra_args = {},
                    const bool coins_db_in_memory = true,
                    const bool block_tree_db_in_memory = true,
@@ -215,7 +217,7 @@ struct TestChainV19Setup : public TestChainV19BeforeActivationSetup {
  */
 struct TestChain100Setup : public TestChainSetup {
     TestChain100Setup(
-        const std::string& chain_name = CBaseChainParams::REGTEST,
+        const ChainType chain_type = ChainType::REGTEST,
         const std::vector<const char*>& extra_args = {},
         const bool coins_db_in_memory = true,
         const bool block_tree_db_in_memory = true,
@@ -227,7 +229,7 @@ struct TestChain100Setup : public TestChainSetup {
  * be used in "hot loops", for example fuzzing or benchmarking.
  */
 template <class T = const BasicTestingSetup>
-std::unique_ptr<T> MakeNoLogFileContext(const std::string& chain_name = CBaseChainParams::REGTEST, const std::vector<const char*>& extra_args = {})
+std::unique_ptr<T> MakeNoLogFileContext(const ChainType chain_type = ChainType::REGTEST, const std::vector<const char*>& extra_args = {})
 {
     const std::vector<const char*> arguments = Cat(
         {
@@ -236,7 +238,7 @@ std::unique_ptr<T> MakeNoLogFileContext(const std::string& chain_name = CBaseCha
         },
         extra_args);
 
-    return std::make_unique<T>(chain_name, arguments);
+    return std::make_unique<T>(chain_type, arguments);
 }
 
 CBlock getBlock13b8a();
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index ad8e1755e8e8..61bb8c88fe5b 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -1825,7 +1825,7 @@ BOOST_AUTO_TEST_CASE(message_hash)
 
 BOOST_AUTO_TEST_CASE(remove_prefix)
 {
-    BOOST_CHECK_EQUAL(RemovePrefix("./util/system.h", "./"), "util/system.h");
+    BOOST_CHECK_EQUAL(RemovePrefix("./common/system.h", "./"), "common/system.h");
     BOOST_CHECK_EQUAL(RemovePrefixView("foo", "foo"), "");
     BOOST_CHECK_EQUAL(RemovePrefix("foo", "fo"), "o");
     BOOST_CHECK_EQUAL(RemovePrefixView("foo", "f"), "oo");
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index 7699c2d07186..925537c8fe82 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -109,7 +109,7 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
     std::shared_ptr<CBlock> pblockone = std::make_shared<CBlock>();
     {
         LOCK(::cs_main);
-        BOOST_REQUIRE(node::ReadBlockFromDisk(*pblockone, chainman.ActiveChain()[1], chainman.GetConsensus()));
+        BOOST_REQUIRE(chainman.m_blockman.ReadBlockFromDisk(*pblockone, *chainman.ActiveChain()[1]));
     }
 
     BOOST_REQUIRE(CreateAndActivateUTXOSnapshot(
@@ -190,7 +190,7 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
 struct V19AboveSnapshotSetup : public TestChain100Setup {
     static constexpr int V19_HEIGHT{150};
     V19AboveSnapshotSetup() :
-        TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=v19@150"}}
+        TestChain100Setup{ChainType::REGTEST, {"-testactivationheight=v19@150"}}
     {
     }
 };
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
index b01930dd4a32..304386d600dc 100644
--- a/src/test/validation_chainstatemanager_tests.cpp
+++ b/src/test/validation_chainstatemanager_tests.cpp
@@ -9,6 +9,7 @@
 #include <governance/superblock.h>
 #include <kernel/disconnected_transactions.h>
 #include <node/chainstate.h>
+#include <node/kernel_notifications.h>
 #include <node/utxo_snapshot.h>
 #include <random.h>
 #include <rpc/blockchain.h>
@@ -37,6 +38,8 @@
 
 #include <boost/test/unit_test.hpp>
 
+using node::BlockManager;
+using node::KernelNotifications;
 using node::SnapshotMetadata;
 
 namespace {
@@ -211,7 +214,7 @@ struct SnapshotTestSetup : TestChain100Setup {
     // tests, but we can't otherwise test this functionality since it relies on
     // destructive filesystem operations.
     SnapshotTestSetup() : TestChain100Setup{
-                              CBaseChainParams::REGTEST,
+                              ChainType::REGTEST,
                               {},
                               /*coins_db_in_memory=*/false,
                               /*block_tree_db_in_memory=*/false,
@@ -229,7 +232,7 @@ struct SnapshotTestSetup : TestChain100Setup {
         {
             LOCK(::cs_main);
             BOOST_CHECK(!chainman.IsSnapshotValidated());
-            BOOST_CHECK(!node::FindSnapshotChainstateDir());
+            BOOST_CHECK(!node::FindSnapshotChainstateDir(m_args.GetDataDirNet()));
         }
 
         size_t initial_size;
@@ -279,7 +282,7 @@ struct SnapshotTestSetup : TestChain100Setup {
                 auto_infile >> coin;
         }));
 
-        BOOST_CHECK(!node::FindSnapshotChainstateDir());
+        BOOST_CHECK(!node::FindSnapshotChainstateDir(m_args.GetDataDirNet()));
 
         BOOST_REQUIRE(!CreateAndActivateUTXOSnapshot(
             this, [](AutoFile& auto_infile, SnapshotMetadata& metadata) {
@@ -303,7 +306,7 @@ struct SnapshotTestSetup : TestChain100Setup {
         }));
 
         BOOST_REQUIRE(CreateAndActivateUTXOSnapshot(this));
-        BOOST_CHECK(fs::exists(*node::FindSnapshotChainstateDir()));
+        BOOST_CHECK(fs::exists(*node::FindSnapshotChainstateDir(m_args.GetDataDirNet())));
 
         // Ensure our active chain is the snapshot chainstate.
         BOOST_CHECK(!chainman.ActiveChainstate().m_from_snapshot_blockhash->IsNull());
@@ -325,7 +328,7 @@ struct SnapshotTestSetup : TestChain100Setup {
         {
             LOCK(::cs_main);
 
-            fs::path found = *node::FindSnapshotChainstateDir();
+            fs::path found = *node::FindSnapshotChainstateDir(m_args.GetDataDirNet());
 
             // Note: WriteSnapshotBaseBlockhash() is implicitly tested above.
             BOOST_CHECK_EQUAL(
@@ -438,16 +441,22 @@ struct SnapshotTestSetup : TestChain100Setup {
             m_node.llmq_ctx.reset();
             chainman.ResetChainstates();
             BOOST_CHECK_EQUAL(chainman.GetAll().size(), 0);
+            m_node.notifications = std::make_unique<KernelNotifications>();
             const ChainstateManager::Options chainman_opts{
                 .chainparams = ::Params(),
                 .datadir = m_args.GetDataDirNet(),
                 .superblock_status = [&sbman = *m_node.sbman](const CDeterministicMNList& mn_list, int height) { return sbman.GetStatus(mn_list, height); },
                 .mn_sync = m_node.mn_sync.get(),
+                .notifications = *m_node.notifications,
+            };
+            const BlockManager::Options blockman_opts{
+                .chainparams = chainman_opts.chainparams,
+                .blocks_dir = m_args.GetBlocksDirPath(),
             };
             // For robustness, ensure the old manager is destroyed before creating a
             // new one.
             m_node.chainman.reset();
-            m_node.chainman = std::make_unique<ChainstateManager>(chainman_opts, node::BlockManager::Options{.chainparams = ::Params()});
+            m_node.chainman = std::make_unique<ChainstateManager>(chainman_opts, blockman_opts);
         }
         return *Assert(m_node.chainman);
     }
@@ -620,7 +629,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
 
     this->SetupSnapshot();
 
-    fs::path snapshot_chainstate_dir = *node::FindSnapshotChainstateDir();
+    fs::path snapshot_chainstate_dir = *node::FindSnapshotChainstateDir(m_args.GetDataDirNet());
     BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
     BOOST_CHECK_EQUAL(snapshot_chainstate_dir, gArgs.GetDataDirNet() / "chainstate_snapshot");
 
@@ -796,7 +805,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_mined_commitment_is_chain_aware, Snaps
         BOOST_CHECK_EQUAL(qblockman.GetNumCommitmentsRequired(llmq_params, background_chainstate->m_chain, target_height), 1);
 
         CBlock block;
-        BOOST_REQUIRE(node::ReadBlockFromDisk(block, snapshot_mined_block, Params().GetConsensus()));
+        BOOST_REQUIRE(m_node.chainman->m_blockman.ReadBlockFromDisk(block, *snapshot_mined_block));
         BlockValidationState state;
         BOOST_CHECK(qblockman.ProcessBlock(*background_chainstate, block, snapshot_mined_block, state,
                                            /*fJustCheck=*/true, /*fBLSChecks=*/false));
@@ -889,7 +898,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init_missing_evodb_marker, Sn
 BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_discarded_on_reindex, SnapshotTestSetup)
 {
     this->SetupSnapshot();
-    BOOST_REQUIRE(node::FindSnapshotChainstateDir());
+    BOOST_REQUIRE(node::FindSnapshotChainstateDir(m_args.GetDataDirNet()));
 
     this->SimulateNodeRestart();
     m_args.ForceSetArg("-reindex-chainstate", "1");
@@ -898,7 +907,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_discarded_on_reindex, Snapsho
 
     ChainstateManager& reindexed = *Assert(m_node.chainman);
     LOCK(::cs_main);
-    BOOST_CHECK(!node::FindSnapshotChainstateDir());
+    BOOST_CHECK(!node::FindSnapshotChainstateDir(m_args.GetDataDirNet()));
     BOOST_CHECK(!reindexed.IsSnapshotActive());
     BOOST_CHECK_EQUAL(reindexed.GetAll().size(), 1);
     uint256 stale_marker;
@@ -917,7 +926,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion, SnapshotTestSetup
     SnapshotCompletionResult res;
     auto mock_shutdown = [](bilingual_str msg) {};
 
-    fs::path snapshot_chainstate_dir = *node::FindSnapshotChainstateDir();
+    fs::path snapshot_chainstate_dir = *node::FindSnapshotChainstateDir(m_args.GetDataDirNet());
     BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
     BOOST_CHECK_EQUAL(snapshot_chainstate_dir, gArgs.GetDataDirNet() / "chainstate_snapshot");
 
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index f7a938196eec..bd7a7f7ecce3 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -9,6 +9,7 @@
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <uint256.h>
+#include <util/chaintype.h>
 #include <validation.h>
 #include <version.h>
 
@@ -21,7 +22,7 @@ BOOST_FIXTURE_TEST_SUITE(validation_tests, TestingSetup)
 //! Test retrieval of valid assumeutxo values.
 BOOST_AUTO_TEST_CASE(test_assumeutxo)
 {
-    const auto params = CreateChainParams(*m_node.args, CBaseChainParams::REGTEST);
+    const auto params = CreateChainParams(*m_node.args, ChainType::REGTEST);
 
     // These heights don't have assumeutxo configurations associated, per the contents
     // of kernel/chainparams.cpp.
diff --git a/src/test/validationinterface_tests.cpp b/src/test/validationinterface_tests.cpp
index 11f8c5a53ee9..fcd0b25b3887 100644
--- a/src/test/validationinterface_tests.cpp
+++ b/src/test/validationinterface_tests.cpp
@@ -10,6 +10,8 @@
 #include <util/check.h>
 #include <validationinterface.h>
 
+#include <atomic>
+
 BOOST_FIXTURE_TEST_SUITE(validationinterface_tests, ChainTestingSetup)
 
 struct TestSubscriberNoop final : public CValidationInterface {
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
index 6770f1d76a97..c17fa008eb43 100644
--- a/src/test/versionbits_tests.cpp
+++ b/src/test/versionbits_tests.cpp
@@ -7,6 +7,7 @@
 #include <consensus/params.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <versionbits.h>
 
 #include <boost/test/unit_test.hpp>
@@ -438,7 +439,7 @@ BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
 
     // check that any deployment on any chain can conceivably reach both
     // ACTIVE and FAILED states in roughly the way we expect
-    for (const auto& chain_name : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET, /*CBaseChainParams::DEVNET,=*/CBaseChainParams::DEVNET, CBaseChainParams::REGTEST}) {
+    for (const auto& chain_name : {ChainType::MAIN, ChainType::TESTNET, /*ChainType::DEVNET,=*/ChainType::DEVNET, ChainType::REGTEST}) {
         const auto chainParams = CreateChainParams(*m_node.args, chain_name);
 
         uint32_t chain_all_vbits{0};
@@ -461,7 +462,7 @@ BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
         // deployment that's not always/never active
         ArgsManager args;
         args.ForceSetArg("-vbparams", "testdummy:1199145601:1230767999"); // January 1, 2008 - December 31, 2008
-        const auto chainParams = CreateChainParams(args, CBaseChainParams::REGTEST);
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
         check_computeblockversion(vbcache, chainParams->GetConsensus(), Consensus::DEPLOYMENT_TESTDUMMY);
     }
 
@@ -471,7 +472,7 @@ BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
         // live deployment
         ArgsManager args;
         args.ForceSetArg("-vbparams", "testdummy:1199145601:1230767999:403200"); // January 1, 2008 - December 31, 2008, min act height 403200
-        const auto chainParams = CreateChainParams(args, CBaseChainParams::REGTEST);
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
         check_computeblockversion(vbcache, chainParams->GetConsensus(), Consensus::DEPLOYMENT_TESTDUMMY);
     }
 }
@@ -480,9 +481,9 @@ BOOST_AUTO_TEST_CASE(evo_shares_follows_v24)
 {
     // evo_shares lifts restrictions that v24 introduces. Its consensus parameters ship in v24 and must
     // stay identical in the release that signals for it, so they mirror v24's on every network.
-    for (const auto& chain_name : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::DEVNET,
-                                   CBaseChainParams::REGTEST}) {
-        BOOST_TEST_MESSAGE(chain_name);
+    for (const auto& chain_name : {ChainType::MAIN, ChainType::TESTNET, ChainType::DEVNET,
+                                   ChainType::REGTEST}) {
+        BOOST_TEST_MESSAGE(ChainTypeToString(chain_name));
         const auto chainParams = CreateChainParams(*m_node.args, chain_name);
         const auto& v24{chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_V24]};
         const auto& evo_shares{chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_EVO_SHARES]};
diff --git a/src/timedata.cpp b/src/timedata.cpp
index a0646b47078c..15ca90ee6a05 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -8,11 +8,12 @@
 
 #include <timedata.h>
 
+#include <common/args.h>
+#include <logging.h>
 #include <netaddress.h>
 #include <node/interface_ui.h>
 #include <sync.h>
 #include <tinyformat.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <warnings.h>
 
diff --git a/src/torcontrol.cpp b/src/torcontrol.cpp
index 59682fe352b1..2a4506739676 100644
--- a/src/torcontrol.cpp
+++ b/src/torcontrol.cpp
@@ -7,8 +7,11 @@
 
 #include <chainparams.h>
 #include <chainparamsbase.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <compat/compat.h>
 #include <crypto/hmac_sha256.h>
+#include <logging.h>
 #include <net.h>
 #include <netaddress.h>
 #include <netbase.h>
@@ -18,7 +21,6 @@
 #include <util/readwritefile.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/thread.h>
 #include <util/time.h>
 
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 6d5817d34c54..0a2a6b1a7edc 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -7,6 +7,7 @@
 #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>
@@ -17,7 +18,6 @@
 #include <random.h>
 #include <shutdown.h>
 #include <uint256.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <util/vector.h>
 
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index f7d0285d2c75..26eb67e7b6e4 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -7,11 +7,13 @@
 
 #include <chain.h>
 #include <coins.h>
+#include <common/system.h>
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <hash.h>
 #include <index/addressindex_util.h>
+#include <logging.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -19,7 +21,6 @@
 #include <util/moneystr.h>
 #include <util/overflow.h>
 #include <util/result.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <util/trace.h>
 #include <util/translation.h>
diff --git a/src/util/any.h b/src/util/any.h
new file mode 100644
index 000000000000..4562c5bd8aac
--- /dev/null
+++ b/src/util/any.h
@@ -0,0 +1,26 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_ANY_H
+#define BITCOIN_UTIL_ANY_H
+
+#include <any>
+
+namespace util {
+
+/**
+ * Helper function to access the contained object of a std::any instance.
+ * Returns a pointer to the object if passed instance has a value and the type
+ * matches, nullptr otherwise.
+ */
+template<typename T>
+T* AnyPtr(const std::any& any) noexcept
+{
+    T* const* ptr = std::any_cast<T*>(&any);
+    return ptr ? *ptr : nullptr;
+}
+
+} // namespace util
+
+#endif // BITCOIN_UTIL_ANY_H
diff --git a/src/util/batchpriority.cpp b/src/util/batchpriority.cpp
new file mode 100644
index 000000000000..c73aef1eb48b
--- /dev/null
+++ b/src/util/batchpriority.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <logging.h>
+#include <util/syserror.h>
+
+#if (defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__))
+#include <pthread.h>
+#include <pthread_np.h>
+#endif
+
+#ifndef WIN32
+#include <sched.h>
+#endif
+
+void ScheduleBatchPriority()
+{
+#ifdef SCHED_BATCH
+    const static sched_param param{};
+    const int rc = pthread_setschedparam(pthread_self(), SCHED_BATCH, &param);
+    if (rc != 0) {
+        LogPrintf("Failed to pthread_setschedparam: %s\n", SysErrorString(rc));
+    }
+#endif
+}
diff --git a/src/util/batchpriority.h b/src/util/batchpriority.h
new file mode 100644
index 000000000000..5ffc8dd684d6
--- /dev/null
+++ b/src/util/batchpriority.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_BATCHPRIORITY_H
+#define BITCOIN_UTIL_BATCHPRIORITY_H
+
+/**
+ * On platforms that support it, tell the kernel the calling thread is
+ * CPU-intensive and non-interactive. See SCHED_BATCH in sched(7) for details.
+ *
+ */
+void ScheduleBatchPriority();
+
+#endif // BITCOIN_UTIL_BATCHPRIORITY_H
diff --git a/src/util/chaintype.cpp b/src/util/chaintype.cpp
new file mode 100644
index 000000000000..3bd6019372ee
--- /dev/null
+++ b/src/util/chaintype.cpp
@@ -0,0 +1,39 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util/chaintype.h>
+
+#include <cassert>
+#include <optional>
+#include <string>
+
+std::string ChainTypeToString(ChainType chain)
+{
+    switch (chain) {
+    case ChainType::MAIN:
+        return "main";
+    case ChainType::TESTNET:
+        return "test";
+    case ChainType::DEVNET:
+        return "devnet";
+    case ChainType::REGTEST:
+        return "regtest";
+    }
+    assert(false);
+}
+
+std::optional<ChainType> ChainTypeFromString(std::string_view chain)
+{
+    if (chain == "main") {
+        return ChainType::MAIN;
+    } else if (chain == "test") {
+        return ChainType::TESTNET;
+    } else if (chain == "devnet") {
+        return ChainType::DEVNET;
+    } else if (chain == "regtest") {
+        return ChainType::REGTEST;
+    } else {
+        return std::nullopt;
+    }
+}
diff --git a/src/util/chaintype.h b/src/util/chaintype.h
new file mode 100644
index 000000000000..1f4edef4b9b5
--- /dev/null
+++ b/src/util/chaintype.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_CHAINTYPE_H
+#define BITCOIN_UTIL_CHAINTYPE_H
+
+#include <optional>
+#include <string>
+
+enum class ChainType {
+    MAIN,
+    TESTNET,
+    DEVNET,
+    REGTEST,
+};
+
+std::string ChainTypeToString(ChainType chain);
+
+std::optional<ChainType> ChainTypeFromString(std::string_view chain);
+
+#endif // BITCOIN_UTIL_CHAINTYPE_H
diff --git a/src/util/insert.h b/src/util/insert.h
new file mode 100644
index 000000000000..5332eca60a32
--- /dev/null
+++ b/src/util/insert.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_INSERT_H
+#define BITCOIN_UTIL_INSERT_H
+
+#include <set>
+
+namespace util {
+
+//! Simplification of std insertion
+template <typename Tdst, typename Tsrc>
+inline void insert(Tdst& dst, const Tsrc& src) {
+    dst.insert(dst.begin(), src.begin(), src.end());
+}
+template <typename TsetT, typename Tsrc>
+inline void insert(std::set<TsetT>& dst, const Tsrc& src) {
+    dst.insert(src.begin(), src.end());
+}
+
+} // namespace util
+
+#endif // BITCOIN_UTIL_INSERT_H
diff --git a/src/util/sock.cpp b/src/util/sock.cpp
index ce2687eaa9d3..97a8eb822670 100644
--- a/src/util/sock.cpp
+++ b/src/util/sock.cpp
@@ -2,12 +2,12 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <common/system.h>
 #include <compat/compat.h>
 #include <logging.h>
 #include <tinyformat.h>
 #include <util/sock.h>
 #include <util/syserror.h>
-#include <util/system.h>
 #include <util/threadinterrupt.h>
 #include <util/time.h>
 
diff --git a/src/validation.cpp b/src/validation.cpp
index cafb278dd56d..820307c67e42 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -18,6 +18,7 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <checkqueue.h>
+#include <common/args.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
@@ -30,6 +31,7 @@
 #include <kernel/chainparams.h>
 #include <kernel/disconnected_transactions.h>
 #include <kernel/mempool_entry.h>
+#include <kernel/notifications_interface.h>
 #include <logging.h>
 #include <logging/timer.h>
 #include <node/blockstorage.h>
@@ -57,7 +59,6 @@
 #include <util/time.h>
 #include <util/trace.h>
 #include <util/translation.h>
-#include <util/system.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
@@ -91,6 +92,7 @@ using kernel::CCoinsStats;
 using kernel::CoinStatsHashType;
 using kernel::ComputeUTXOStats;
 using kernel::LoadMempool;
+using kernel::Notifications;
 
 using fsbridge::FopenFn;
 using node::BlockManager;
@@ -98,10 +100,7 @@ using node::BlockMap;
 using node::CBlockIndexHeightOnlyComparator;
 using node::CBlockIndexWorkComparator;
 using node::fReindex;
-using node::ReadBlockFromDisk;
 using node::SnapshotMetadata;
-using node::UndoReadFromDisk;
-using node::UnlinkPrunedFiles;
 
 /** Time to wait between writing blocks/block index to disk. */
 static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL{1};
@@ -131,7 +130,7 @@ 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, const Consensus::Params& consensusParams, uint256& hashBlock);
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
 } // namespace node
 using node::GetTransaction;
 
@@ -908,7 +907,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         auto& [_, conflict_txid] = conflictLockOpt.value();
 
         uint256 hashBlock;
-        if (auto txConflict = GetTransaction(nullptr, &m_pool, conflict_txid, chainparams.GetConsensus(), hashBlock); txConflict) {
+        if (auto txConflict = GetTransaction(nullptr, &m_pool, conflict_txid, hashBlock, m_active_chainstate.m_blockman); txConflict) {
             GetMainSignals().NotifyInstantSendDoubleSpendAttempt(ptx, txConflict);
         }
         LogPrintf("ERROR: AcceptToMemoryPool : Transaction %s conflicts with locked TX %s\n", hash.ToString(), conflict_txid.ToString());
@@ -1831,14 +1830,14 @@ static std::pair<CAmount, CAmount> GetBlockSubsidyHelper(int nPrevBits, int nPre
     double dDiff;
     CAmount nSubsidyBase;
 
-    if (nPrevHeight <= 4500 && Params().NetworkIDString() == CBaseChainParams::MAIN) {
+    if (nPrevHeight <= 4500 && Params().GetChainType() == ChainType::MAIN) {
         /* a bug which caused diff to not be correctly calculated */
         dDiff = (double)0x0000ffff / (double)(nPrevBits & 0x00ffffff);
     } else {
         dDiff = ConvertBitsToDouble(nPrevBits);
     }
 
-    const bool isDevnet = Params().NetworkIDString() == CBaseChainParams::DEVNET;
+    const bool isDevnet = Params().GetChainType() == ChainType::DEVNET;
     const bool force_fixed_base_subsidy = fV20Active || (isDevnet && nPrevHeight >= consensusParams.nHighSubsidyBlocks);
     if (force_fixed_base_subsidy) {
         // Originally, nSubsidyBase calculations relied on difficulty. Once Platform is live,
@@ -2037,26 +2036,6 @@ bool Chainstate::IsInitialBlockDownload() const
     return false;
 }
 
-static void AlertNotify(const std::string& strMessage)
-{
-    uiInterface.NotifyAlertChanged();
-#if HAVE_SYSTEM
-    std::string strCmd = gArgs.GetArg("-alertnotify", "");
-    if (strCmd.empty()) return;
-
-    // Alert text should be plain ascii coming from a trusted source, but to
-    // be safe we first strip anything not in safeChars, then add single quotes around
-    // the whole string before passing it to the shell:
-    std::string singleQuote("'");
-    std::string safeStatus = SanitizeString(strMessage);
-    safeStatus = singleQuote+safeStatus+singleQuote;
-    ReplaceAll(strCmd, "%s", safeStatus);
-
-    std::thread t(runCommand, strCmd);
-    t.detach(); // thread runs free
-#endif
-}
-
 void Chainstate::CheckForkWarningConditions()
 {
     AssertLockHeld(cs_main);
@@ -2339,7 +2318,7 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
     bool fClean = true;
 
     CBlockUndo blockUndo;
-    if (!UndoReadFromDisk(blockUndo, pindex)) {
+    if (!m_blockman.UndoReadFromDisk(blockUndo, *pindex)) {
         LogError("DisconnectBlock(): failure reading undo data\n");
         return DISCONNECT_FAILED;
     }
@@ -3269,7 +3248,7 @@ bool Chainstate::FlushStateToDisk(
         // Write blocks and block index to disk.
         if (fDoFullFlush || fPeriodicWrite) {
             // Ensure we can write block index
-            if (!CheckDiskSpace(gArgs.GetBlocksDirPath())) {
+            if (!CheckDiskSpace(m_blockman.m_opts.blocks_dir)) {
                 return AbortNode(state, "Disk space is too low!", _("Disk space is too low!"));
             }
             // First make sure all block and undo data is flushed to disk.
@@ -3296,7 +3275,7 @@ bool Chainstate::FlushStateToDisk(
             if (fFlushForPrune) {
                 LOG_TIME_MILLIS_WITH_CATEGORY("unlink pruned files", BCLog::BENCHMARK);
 
-                UnlinkPrunedFiles(setFilesToPrune);
+                m_blockman.UnlinkPrunedFiles(setFilesToPrune);
             }
             m_last_write = nNow;
         }
@@ -3311,7 +3290,7 @@ bool Chainstate::FlushStateToDisk(
                 // twice (once in the log, and once in the tables). This is already
                 // an overestimation, as most will delete an existing entry or
                 // overwrite one. Still, use a conservative safety factor of 2.
-                if (!CheckDiskSpace(gArgs.GetDataDirNet(), 48 * 2 * 2 * CoinsTip().GetCacheSize())) {
+                if (!CheckDiskSpace(m_chainman.m_options.datadir, 48 * 2 * 2 * CoinsTip().GetCacheSize())) {
                     return AbortNode(state, "Disk space is too low!", _("Disk space is too low!"));
                 }
                 // Flush the chainstate (which may refer to block index entries).
@@ -3373,16 +3352,6 @@ void Chainstate::PruneAndFlush()
     }
 }
 
-static void DoWarning(const bilingual_str& warning)
-{
-    static bool fWarned = false;
-    SetMiscWarning(warning);
-    if (!fWarned) {
-        AlertNotify(warning.original);
-        fWarned = true;
-    }
-}
-
 /** Private helper function that concatenates warning messages. */
 static void AppendWarning(bilingual_str& res, const bilingual_str& warn)
 {
@@ -3452,7 +3421,7 @@ void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
             if (state == ThresholdState::ACTIVE || state == ThresholdState::LOCKED_IN) {
                 const bilingual_str warning = strprintf(_("Unknown new rules activated (versionbit %i)"), bit);
                 if (state == ThresholdState::ACTIVE) {
-                    DoWarning(warning);
+                    m_chainman.GetNotifications().warning(warning);
                 } else {
                     AppendWarning(warning_messages, warning);
                 }
@@ -3485,7 +3454,7 @@ bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTra
     // Read block from disk.
     std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
     CBlock& block = *pblock;
-    if (!ReadBlockFromDisk(block, pindexDelete, m_chainman.GetConsensus())) {
+    if (!m_blockman.ReadBlockFromDisk(block, *pindexDelete)) {
         LogError("DisconnectTip(): Failed to read block\n");
         return false;
     }
@@ -3634,7 +3603,7 @@ bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew,
     std::shared_ptr<const CBlock> pthisBlock;
     if (!pblock) {
         std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
-        if (!ReadBlockFromDisk(*pblockNew, pindexNew, m_chainman.GetConsensus())) {
+        if (!m_blockman.ReadBlockFromDisk(*pblockNew, *pindexNew)) {
             return AbortNode(state, "Failed to read block");
         }
         pthisBlock = pblockNew;
@@ -3933,7 +3902,7 @@ static bool NotifyHeaderTip(Chainstate& chainstate) LOCKS_EXCLUDED(cs_main) {
     }
     // Send block tip changed notifications without cs_main
     if (fNotify) {
-        uiInterface.NotifyHeaderTip(GetSynchronizationState(fInitialBlockDownload), pindexHeader->nHeight, pindexHeader->nTime);
+        chainstate.m_chainman.GetNotifications().headerTip(GetSynchronizationState(fInitialBlockDownload), pindexHeader->nHeight, pindexHeader->nTime, false);
         GetMainSignals().NotifyHeaderTip(pindexHeader, fInitialBlockDownload);
     }
     return fNotify;
@@ -3975,7 +3944,6 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
 
     CBlockIndex *pindexMostWork = nullptr;
     CBlockIndex *pindexNewTip = nullptr;
-    int nStopAtHeight = gArgs.GetIntArg("-stopatheight", DEFAULT_STOPATHEIGHT);
     do {
         // Block until the validation queue drains. This should largely
         // never happen in normal operation, however may happen during
@@ -4048,12 +4016,12 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
                 GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork, fInitialDownload);
 
                 // Always notify the UI if a new block tip was connected
-                uiInterface.NotifyBlockTip(GetSynchronizationState(fInitialDownload), pindexNewTip);
+                m_chainman.GetNotifications().blockTip(GetSynchronizationState(fInitialDownload), *pindexNewTip);
             }
         }
         // When we reach this point, we switched to a new tip (stored in pindexNewTip).
 
-        if (nStopAtHeight && pindexNewTip && pindexNewTip->nHeight >= nStopAtHeight) StartShutdown();
+        if (m_chainman.StopAtHeight() && pindexNewTip && pindexNewTip->nHeight >= m_chainman.StopAtHeight()) StartShutdown();
 
         if (WITH_LOCK(::cs_main, return m_disabled)) {
             // Background chainstate has reached the snapshot base block, so exit.
@@ -4266,7 +4234,7 @@ bool Chainstate::InvalidateBlock(BlockValidationState& state, CBlockIndex* pinde
 
     // Only notify about a new block tip if the active chain was modified.
     if (pindex_was_in_chain) {
-        uiInterface.NotifyBlockTip(GetSynchronizationState(IsInitialBlockDownload()), to_mark_failed->pprev);
+        m_chainman.GetNotifications().blockTip(GetSynchronizationState(IsInitialBlockDownload()), *to_mark_failed->pprev);
     }
     return true;
 }
@@ -4370,7 +4338,7 @@ bool Chainstate::MarkConflictingBlock(BlockValidationState& state, CBlockIndex *
 
     // Only notify about a new block tip if the active chain was modified.
     if (pindex_was_in_chain) {
-        uiInterface.NotifyBlockTip(GetSynchronizationState(IsInitialBlockDownload()), pindex->pprev);
+        m_chainman.GetNotifications().blockTip(GetSynchronizationState(IsInitialBlockDownload()), *pindex->pprev);
     }
     return true;
 }
@@ -4699,7 +4667,7 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
     const int nHeight = pindexPrev->nHeight + 1;
 
     // Check proof of work
-    if (chainman.GetParams().NetworkIDString() == CBaseChainParams::MAIN && nHeight <= 68589){
+    if (chainman.GetParams().GetChainType() == ChainType::MAIN && nHeight <= 68589){
         // architecture issues with DGW v1 and v2)
         unsigned int nBitsNext = GetNextWorkRequired(pindexPrev, &block, chainman.GetConsensus());
         double n1 = ConvertBitsToDouble(block.nBits);
@@ -5244,14 +5212,15 @@ bool Chainstate::LoadChainTip()
     return true;
 }
 
-CVerifyDB::CVerifyDB()
+CVerifyDB::CVerifyDB(Notifications& notifications)
+    : m_notifications{notifications}
 {
-    uiInterface.ShowProgress(_("Verifying blocks…").translated, 0, false);
+    m_notifications.progress(_("Verifying blocks…"), 0, false);
 }
 
 CVerifyDB::~CVerifyDB()
 {
-    uiInterface.ShowProgress("", 100, false);
+    m_notifications.progress(bilingual_str{}, 100, false);
 }
 
 VerifyDBResult CVerifyDB::VerifyDB(
@@ -5298,7 +5267,7 @@ VerifyDBResult CVerifyDB::VerifyDB(
             LogPrintf("Verification progress: %d%%\n", percentageDone);
             reportDone = percentageDone / 10;
         }
-        uiInterface.ShowProgress(_("Verifying blocks…").translated, percentageDone, false);
+        m_notifications.progress(_("Verifying blocks…"), percentageDone, false);
         if (pindex->nHeight <= chainstate.m_chain.Height() - nCheckDepth) {
             break;
         }
@@ -5311,7 +5280,7 @@ VerifyDBResult CVerifyDB::VerifyDB(
         }
         CBlock block;
         // check level 0: read from disk
-        if (!ReadBlockFromDisk(block, pindex, consensus_params)) {
+        if (!chainstate.m_blockman.ReadBlockFromDisk(block, *pindex)) {
             LogError("Verification error: ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
             return VerifyDBResult::CORRUPTED_BLOCK_DB;
         }
@@ -5325,7 +5294,7 @@ VerifyDBResult CVerifyDB::VerifyDB(
         if (nCheckLevel >= 2 && pindex) {
             CBlockUndo undo;
             if (!pindex->GetUndoPos().IsNull()) {
-                if (!UndoReadFromDisk(undo, pindex)) {
+                if (!chainstate.m_blockman.UndoReadFromDisk(undo, *pindex)) {
                     LogError("Verification error: found bad undo data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
                     return VerifyDBResult::CORRUPTED_BLOCK_DB;
                 }
@@ -5377,10 +5346,10 @@ VerifyDBResult CVerifyDB::VerifyDB(
                 LogPrintf("Verification progress: %d%%\n", percentageDone);
                 reportDone = percentageDone / 10;
             }
-            uiInterface.ShowProgress(_("Verifying blocks…").translated, percentageDone, false);
+            m_notifications.progress(_("Verifying blocks…"), percentageDone, false);
             pindex = chainstate.m_chain.Next(pindex);
             CBlock block;
-            if (!ReadBlockFromDisk(block, pindex, consensus_params)) {
+            if (!chainstate.m_blockman.ReadBlockFromDisk(block, *pindex)) {
                 LogError("Verification error: ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
                 return VerifyDBResult::CORRUPTED_BLOCK_DB;
             }
@@ -5410,7 +5379,7 @@ bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& in
 
     // TODO: merge with ConnectBlock
     CBlock block;
-    if (!ReadBlockFromDisk(block, pindex,m_chainman.GetConsensus())) {
+    if (!m_blockman.ReadBlockFromDisk(block, *pindex)) {
         LogError("RollforwardBlock(): ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
         return false;
     }
@@ -5461,7 +5430,7 @@ bool Chainstate::ReplayBlocks()
         return false;
     }
 
-    uiInterface.ShowProgress(_("Replaying blocks…").translated, 0, false);
+    m_chainman.GetNotifications().progress(_("Replaying blocks…"), 0, false);
     LogPrintf("Replaying blocks\n");
 
     const CBlockIndex* pindexOld = nullptr;  // Old tip during the interrupted flush.
@@ -5495,7 +5464,7 @@ bool Chainstate::ReplayBlocks()
     while (pindexOld != pindexFork) {
         if (pindexOld->nHeight > 0) { // Never disconnect the genesis block.
             CBlock block;
-            if (!ReadBlockFromDisk(block, pindexOld, m_chainman.GetConsensus())) {
+            if (!m_blockman.ReadBlockFromDisk(block, *pindexOld)) {
                 LogError("ReplayBlocks(): ReadBlockFromDisk() failed at %d, hash=%s\n", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
                 return false;
             }
@@ -5519,7 +5488,7 @@ bool Chainstate::ReplayBlocks()
         const CBlockIndex& pindex{*Assert(pindexNew->GetAncestor(nHeight))};
 
         LogPrintf("Rolling forward %s (%i)\n", pindex.GetBlockHash().ToString(), nHeight);
-        uiInterface.ShowProgress(_("Replaying blocks…").translated, (int) ((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)) , false);
+        m_chainman.GetNotifications().progress(_("Replaying blocks…"), (int)((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)), false);
         // Special transaction and quorum commitment checks read the chain, which
         // LoadChainTip() has not set yet; give them the view ConnectBlock had.
         // Stopping at the parent also keeps LoadChainTip() from skipping its
@@ -5533,7 +5502,7 @@ bool Chainstate::ReplayBlocks()
     bool flushed = cache.Flush();
     assert(flushed);
     dbTx->Commit();
-    uiInterface.ShowProgress("", 100, false);
+    m_chainman.GetNotifications().progress(bilingual_str{}, 100, false);
     return true;
 }
 
@@ -5639,7 +5608,7 @@ bool Chainstate::LoadGenesisBlock()
         if (!AddGenesisBlock(params.GenesisBlock(), state))
             return false;
 
-        if (params.NetworkIDString() == CBaseChainParams::DEVNET) {
+        if (params.GetChainType() == ChainType::DEVNET) {
             // We can't continue if devnet genesis block is invalid
             std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(
                     params.DevNetGenesisBlock());
@@ -5800,7 +5769,7 @@ void ChainstateManager::LoadExternalBlockFile(
                     while (range.first != range.second) {
                         std::multimap<uint256, FlatFilePos>::iterator it = range.first;
                         std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
-                        if (auto opt_hash{ReadBlockFromDisk(*pblockrecursive, it->second, params.GetConsensus())}) {
+                        if (auto opt_hash{m_blockman.ReadBlockFromDisk(*pblockrecursive, it->second)}) {
                             const uint256& blockhash = *opt_hash;
                             LogPrint(BCLog::REINDEX, "%s: Processing out of order child %s of %s\n", __func__, blockhash.ToString(),
                                     head.ToString());
@@ -6243,11 +6212,11 @@ static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot)
     return destroyed && !fs::exists(db_path);
 }
 
-bool DeleteSnapshotChainstateFromDisk()
+bool DeleteSnapshotChainstateFromDisk(const fs::path& data_dir)
 {
     AssertLockHeld(::cs_main);
 
-    auto snapshot_datadir = node::FindSnapshotChainstateDir();
+    auto snapshot_datadir = node::FindSnapshotChainstateDir(data_dir);
     if (!snapshot_datadir) {
         return true;
     }
@@ -6351,7 +6320,7 @@ bool ChainstateManager::ActivateSnapshot(
 
         // PopulateAndValidateSnapshot can return (in error) before the leveldb datadir
         // has been created, so only attempt removal if we got that far.
-        if (auto snapshot_datadir = node::FindSnapshotChainstateDir()) {
+        if (auto snapshot_datadir = node::FindSnapshotChainstateDir(m_options.datadir)) {
             // We have to destruct leveldb::DB in order to release the db lock, otherwise
             // DestroyDB() (in DeleteCoinsDBFromDisk()) will fail. See `leveldb::~DBImpl()`.
             // Destructing the chainstate (and so resetting the coinsviews object) does this.
@@ -6914,8 +6883,8 @@ bool ChainstateManager::IsQuorumTypeEnabled(const Consensus::LLMQType llmqType,
     case Consensus::LLMQType::LLMQ_DEVNET:
         return true;
     case Consensus::LLMQType::LLMQ_50_60:
-        return !fDIP0024IsActive || !fHaveDIP0024Quorums || GetParams().NetworkIDString() == CBaseChainParams::TESTNET ||
-               GetParams().NetworkIDString() == CBaseChainParams::DEVNET;
+        return !fDIP0024IsActive || !fHaveDIP0024Quorums || GetParams().GetChainType() == ChainType::TESTNET ||
+               GetParams().GetChainType() == ChainType::DEVNET;
     case Consensus::LLMQType::LLMQ_TEST_INSTANTSEND:
         return !fDIP0024IsActive || !fHaveDIP0024Quorums ||
                GetConsensus().llmqTypeDIP0024InstantSend == Consensus::LLMQType::LLMQ_TEST_INSTANTSEND;
@@ -7052,7 +7021,7 @@ SpecialTxRules GetSpecialTxRules(const CBlockIndex* pindexPrev, const Chainstate
 bool ChainstateManager::DetectSnapshotChainstate(CTxMemPool* mempool, bilingual_str& error)
 {
     assert(!m_snapshot_chainstate);
-    std::optional<fs::path> path = node::FindSnapshotChainstateDir();
+    std::optional<fs::path> path = node::FindSnapshotChainstateDir(m_options.datadir);
     if (!path) {
         return true;
     }
diff --git a/src/validation.h b/src/validation.h
index c51a7d710bcd..a75f9695cb5d 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -83,9 +83,6 @@ static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
  *  less than this number, we reached its tip. Changing this value is a protocol upgrade. */
 static const unsigned int MAX_HEADERS_UNCOMPRESSED_RESULT = 2000;
 static const unsigned int MAX_HEADERS_COMPRESSED_RESULT = 8000;
-
-/** Default for -stopatheight */
-static const int DEFAULT_STOPATHEIGHT = 0;
 /** Blocks within this distance of ActiveChain().Tip() are accepted unrequested and announced by pruned nodes.
  *  Bitcoin Core's MIN_BLOCKS_TO_KEEP; pruning retention is CChainParams::MinBlocksToKeep(). */
 static const unsigned int BLOCKS_NEAR_TIP = 288;
@@ -395,9 +392,13 @@ enum class VerifyDBResult {
 };
 
 /** RAII wrapper for VerifyDB: Verify consistency of the block and coin databases */
-class CVerifyDB {
+class CVerifyDB
+{
+private:
+    kernel::Notifications& m_notifications;
+
 public:
-    CVerifyDB();
+    explicit CVerifyDB(kernel::Notifications& notifications);
     ~CVerifyDB();
     [[nodiscard]] VerifyDBResult VerifyDB(
         Chainstate& chainstate,
@@ -981,6 +982,8 @@ class ChainstateManager
     bool ShouldCheckBlockIndex() const { return *Assert(m_options.check_block_index); }
     const arith_uint256& MinimumChainWork() const { return *Assert(m_options.minimum_chain_work); }
     const uint256& AssumedValidBlock() const { return *Assert(m_options.assumed_valid_block); }
+    kernel::Notifications& GetNotifications() const { return m_options.notifications; };
+    int StopAtHeight() const { return m_options.stop_at_height; };
 
     /**
      * Make various assertions about the state of the block index.
@@ -1327,7 +1330,7 @@ const AssumeutxoData* ExpectedAssumeutxo(const int height, const CChainParams& p
  * @returns false only if a snapshot chainstate was found but could not be fully
  *          removed; true when there was nothing to remove.
  */
-bool DeleteSnapshotChainstateFromDisk() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+bool DeleteSnapshotChainstateFromDisk(const fs::path& data_dir) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
 /** Identifies blocks that overwrote an existing coinbase output in the UTXO set (see BIP30) */
 bool IsBIP30Repeat(const CBlockIndex& block_index);
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index ef4651152931..f2e29ca0c4b9 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -4,10 +4,13 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <compat/compat.h>
+#include <logging.h>
 #include <util/fs.h>
+#include <util/time.h>
 #include <wallet/bdb.h>
 #include <wallet/db.h>
 
+#include <sync.h>
 #include <util/check.h>
 #include <util/fs_helpers.h>
 #include <util/strencodings.h>
diff --git a/src/wallet/bdb.h b/src/wallet/bdb.h
index 7d287f6f25d5..4ef922dbc8f8 100644
--- a/src/wallet/bdb.h
+++ b/src/wallet/bdb.h
@@ -7,12 +7,14 @@
 #define BITCOIN_WALLET_BDB_H
 
 #include <clientversion.h>
+#include <common/system.h>
 #include <serialize.h>
 #include <streams.h>
 #include <util/fs.h>
-#include <util/system.h>
 #include <wallet/db.h>
 
+#include <atomic>
+#include <condition_variable>
 #include <map>
 #include <memory>
 #include <string>
diff --git a/src/wallet/coincontrol.cpp b/src/wallet/coincontrol.cpp
index a5b47b13bbe0..8039bc88df2e 100644
--- a/src/wallet/coincontrol.cpp
+++ b/src/wallet/coincontrol.cpp
@@ -4,7 +4,7 @@
 
 #include <wallet/coincontrol.h>
 
-#include <util/system.h>
+#include <common/args.h>
 
 namespace wallet {
 CCoinControl::CCoinControl(CoinType coinType)
diff --git a/src/wallet/coinselection.cpp b/src/wallet/coinselection.cpp
index a11a3217091d..858faf860f9c 100644
--- a/src/wallet/coinselection.cpp
+++ b/src/wallet/coinselection.cpp
@@ -4,11 +4,12 @@
 
 #include <wallet/coinselection.h>
 
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
+#include <logging.h>
 #include <policy/feerate.h>
 #include <util/check.h>
-#include <util/system.h>
 #include <util/moneystr.h>
 
 #include <coinjoin/common.h>
diff --git a/src/wallet/coinselection.h b/src/wallet/coinselection.h
index b874af9fa8fe..a8ee26a594e2 100644
--- a/src/wallet/coinselection.h
+++ b/src/wallet/coinselection.h
@@ -11,8 +11,8 @@
 #include <primitives/transaction.h>
 #include <random.h>
 #include <util/check.h>
+#include <util/insert.h>
 #include <util/result.h>
-#include <util/system.h>
 
 #include <cstdint>
 #include <optional>
diff --git a/src/wallet/crypter.cpp b/src/wallet/crypter.cpp
index 4918944af24f..551e01e19e9f 100644
--- a/src/wallet/crypter.cpp
+++ b/src/wallet/crypter.cpp
@@ -4,9 +4,10 @@
 
 #include <wallet/crypter.h>
 
+#include <common/system.h>
 #include <crypto/aes.h>
 #include <crypto/sha512.h>
-#include <util/system.h>
+#include <logging.h>
 
 #include <vector>
 
diff --git a/src/wallet/db.cpp b/src/wallet/db.cpp
index 6d13f7efb454..6c99c48f57ff 100644
--- a/src/wallet/db.cpp
+++ b/src/wallet/db.cpp
@@ -4,9 +4,9 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <common/args.h>
 #include <logging.h>
 #include <util/fs.h>
-#include <util/system.h>
 #include <wallet/db.h>
 
 #include <exception>
diff --git a/src/wallet/dump.cpp b/src/wallet/dump.cpp
index 2b13e5d93d4c..42106f46bf1d 100644
--- a/src/wallet/dump.cpp
+++ b/src/wallet/dump.cpp
@@ -4,8 +4,8 @@
 
 #include <wallet/dump.h>
 
+#include <common/args.h>
 #include <util/fs.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
diff --git a/src/wallet/external_signer_scriptpubkeyman.cpp b/src/wallet/external_signer_scriptpubkeyman.cpp
index 6c8d739c7153..fcdea6c5a468 100644
--- a/src/wallet/external_signer_scriptpubkeyman.cpp
+++ b/src/wallet/external_signer_scriptpubkeyman.cpp
@@ -3,6 +3,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <external_signer.h>
 #include <wallet/external_signer_scriptpubkeyman.h>
 
@@ -45,7 +47,7 @@ ExternalSigner ExternalSignerScriptPubKeyMan::GetExternalSigner() {
     const std::string command = gArgs.GetArg("-signer", "");
     if (command == "") throw std::runtime_error(std::string(__func__) + ": restart dashd with -signer=<cmd>");
     std::vector<ExternalSigner> signers;
-    ExternalSigner::Enumerate(command, signers, Params().NetworkIDString());
+    ExternalSigner::Enumerate(command, signers, Params().GetChainTypeString());
     if (signers.empty()) throw std::runtime_error(std::string(__func__) + ": No external signers found");
     // TODO: add fingerprint argument instead of failing in case of multiple signers.
     if (signers.size() > 1) throw std::runtime_error(std::string(__func__) + ": More than one external signer found. Please connect only one at a time.");
diff --git a/src/wallet/hdchain.cpp b/src/wallet/hdchain.cpp
index a8ee2b7b0344..7abb748642ea 100644
--- a/src/wallet/hdchain.cpp
+++ b/src/wallet/hdchain.cpp
@@ -1,12 +1,13 @@
 // Copyright (c) 2014-2025 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 
+#include <common/args.h>
 #include <wallet/hdchain.h>
 
+#include <common/system.h>
 #include <wallet/bip39.h>
 #include <chainparams.h>
 #include <tinyformat.h>
-#include <util/system.h>
 
 #include <algorithm>
 
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index 0b9de2c34f0e..f50eb4733360 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -8,6 +8,8 @@
 #include <config/bitcoin-config.h>
 #endif
 
+#include <common/args.h>
+#include <common/system.h>
 #include <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/init.h>
@@ -18,7 +20,6 @@
 #include <univalue.h>
 #include <util/check.h>
 #include <util/error.h>
-#include <util/system.h>
 #include <util/moneystr.h>
 #include <util/translation.h>
 #include <validation.h>
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 1d8b92a35662..c6d755e9d95d 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -2,6 +2,7 @@
 // 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 <interfaces/wallet.h>
 
 #include <chain.h>
@@ -18,7 +19,6 @@
 #include <sync.h>
 #include <uint256.h>
 #include <util/check.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <util/ui_change_type.h>
 #include <validation.h>
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 317fa2de6988..f8a331a8e749 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -3,6 +3,7 @@
 // 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 <wallet/load.h>
 
 #include <coinjoin/client.h>
@@ -14,7 +15,6 @@
 #include <util/check.h>
 #include <util/fs.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <wallet/context.h>
 #include <wallet/spend.h>
@@ -66,7 +66,7 @@ bool VerifyWallets(WalletContext& context)
         options.require_existing = true;
         options.verify = false;
         if (MakeWalletDatabase("", options, status, error_string)) {
-            util::SettingsValue wallets(util::SettingsValue::VARR);
+            common::SettingsValue wallets(common::SettingsValue::VARR);
             wallets.push_back(""); // Default wallet name is ""
             // Pass write=false because no need to write file and probably
             // better not to. If unnamed wallet needs to be added next startup
diff --git a/src/wallet/rpc/util.cpp b/src/wallet/rpc/util.cpp
index 9da58289d09f..9ef08af60cca 100644
--- a/src/wallet/rpc/util.cpp
+++ b/src/wallet/rpc/util.cpp
@@ -6,7 +6,7 @@
 
 #include <common/url.h>
 #include <rpc/util.h>
-#include <util/system.h>
+#include <util/any.h>
 #include <util/translation.h>
 #include <wallet/context.h>
 #include <wallet/wallet.h>
diff --git a/src/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index 52f527f24a9e..a27d70ef2a1b 100644
--- a/src/wallet/rpc/wallet.cpp
+++ b/src/wallet/rpc/wallet.cpp
@@ -5,6 +5,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <common/args.h>
 #include <common/url.h>
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 38fad606f74c..feee80a11b7f 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -5,6 +5,8 @@
 #include <algorithm>
 #include <coinjoin/common.h>
 #include <coinjoin/options.h>
+#include <common/args.h>
+#include <common/system.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <evo/assetlocktx.h>
diff --git a/src/wallet/test/coinjoin_tests.cpp b/src/wallet/test/coinjoin_tests.cpp
index 33ff44406984..a799fda06072 100644
--- a/src/wallet/test/coinjoin_tests.cpp
+++ b/src/wallet/test/coinjoin_tests.cpp
@@ -2,10 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
+#include <common/args.h>
 #include <test/util/setup_common.h>
 #include <test/util/txmempool.h>
 
@@ -14,11 +11,11 @@
 #include <coinjoin/walletman.h>
 #include <coinjoin/options.h>
 #include <coinjoin/util.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <interfaces/coinjoin.h>
 #include <masternode/sync.h>
 #include <node/context.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <util/time.h>
 #include <validation.h>
diff --git a/src/wallet/test/fuzz/scriptpubkeyman.cpp b/src/wallet/test/fuzz/scriptpubkeyman.cpp
index 180ae692693a..ebb5a0b4319e 100644
--- a/src/wallet/test/fuzz/scriptpubkeyman.cpp
+++ b/src/wallet/test/fuzz/scriptpubkeyman.cpp
@@ -24,7 +24,7 @@ void initialize_spkm()
 {
     static const auto testing_setup{MakeNoLogFileContext<const TestingSetup>()};
     g_setup = testing_setup.get();
-    SelectParams(CBaseChainParams::MAIN);
+    SelectParams(ChainType::MAIN);
     MOCKED_DESC_CONVERTER.Init();
 }
 
diff --git a/src/wallet/test/init_test_fixture.cpp b/src/wallet/test/init_test_fixture.cpp
index 7c33dbcfce3b..276f5f279972 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -2,9 +2,10 @@
 // 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 <univalue.h>
+#include <util/chaintype.h>
 #include <util/fs.h>
-#include <util/system.h>
 
 #include <fstream>
 #include <string>
@@ -12,7 +13,7 @@
 #include <wallet/test/init_test_fixture.h>
 
 namespace wallet {
-InitWalletDirTestingSetup::InitWalletDirTestingSetup(const std::string& chainName) : BasicTestingSetup(chainName)
+InitWalletDirTestingSetup::InitWalletDirTestingSetup(const ChainType chainType) : BasicTestingSetup(chainType)
 {
     m_wallet_loader = MakeWalletLoader(*m_node.chain, m_args, m_node);
 
diff --git a/src/wallet/test/init_test_fixture.h b/src/wallet/test/init_test_fixture.h
index d9f6f79d0043..79e09e722c25 100644
--- a/src/wallet/test/init_test_fixture.h
+++ b/src/wallet/test/init_test_fixture.h
@@ -9,10 +9,11 @@
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 
 namespace wallet {
 struct InitWalletDirTestingSetup: public BasicTestingSetup {
-    explicit InitWalletDirTestingSetup(const std::string& chainName = CBaseChainParams::MAIN);
+    explicit InitWalletDirTestingSetup(const ChainType chain_type = ChainType::MAIN);
     ~InitWalletDirTestingSetup();
     void SetWalletDir(const fs::path& walletdir_path);
 
diff --git a/src/wallet/test/init_tests.cpp b/src/wallet/test/init_tests.cpp
index b49c935de16c..8ee473549b2f 100644
--- a/src/wallet/test/init_tests.cpp
+++ b/src/wallet/test/init_tests.cpp
@@ -4,9 +4,10 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <common/args.h>
+#include <common/system.h>
 #include <noui.h>
 #include <test/util/logging.h>
-#include <util/system.h>
 #include <wallet/test/init_test_fixture.h>
 
 namespace wallet {
diff --git a/src/wallet/test/wallet_test_fixture.cpp b/src/wallet/test/wallet_test_fixture.cpp
index 4d479f6f9c78..01b702116ba9 100644
--- a/src/wallet/test/wallet_test_fixture.cpp
+++ b/src/wallet/test/wallet_test_fixture.cpp
@@ -6,10 +6,11 @@
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <scheduler.h>
+#include <util/chaintype.h>
 
 namespace wallet {
-WalletTestingSetup::WalletTestingSetup(const std::string& chainName)
-    : TestingSetup(chainName),
+WalletTestingSetup::WalletTestingSetup(const ChainType chainType)
+    : TestingSetup(chainType),
       m_wallet_loader{interfaces::MakeWalletLoader(*m_node.chain, *Assert(m_node.args), m_node)},
       m_wallet(m_node.chain.get(), "", CreateMockableWalletDatabase())
 {
diff --git a/src/wallet/test/wallet_test_fixture.h b/src/wallet/test/wallet_test_fixture.h
index f1ef15a2824e..4aae02e075a1 100644
--- a/src/wallet/test/wallet_test_fixture.h
+++ b/src/wallet/test/wallet_test_fixture.h
@@ -10,6 +10,7 @@
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <wallet/wallet.h>
 
@@ -19,7 +20,7 @@ namespace wallet {
 /** Testing setup and teardown for wallet.
  */
 struct WalletTestingSetup : public TestingSetup {
-    explicit WalletTestingSetup(const std::string& chainName = CBaseChainParams::MAIN);
+    explicit WalletTestingSetup(const ChainType chainType = ChainType::MAIN);
     ~WalletTestingSetup();
 
     std::unique_ptr<interfaces::WalletLoader> m_wallet_loader;
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index fc82abcaf9da..e623b8e85401 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -48,7 +48,6 @@
 #include <univalue.h>
 
 using node::MAX_BLOCKFILE_SIZE;
-using node::UnlinkPrunedFiles;
 
 namespace wallet {
 RPCHelpMan importmulti();
@@ -213,7 +212,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
         file_number = oldTip->GetBlockPos().nFile;
         Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
     }
-    UnlinkPrunedFiles({file_number});
+    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
     BOOST_CHECK(rescan_pruned_from() == std::optional<int>{0});
 
     // Verify ScanForWalletTransactions only picks transactions in the new block
@@ -242,7 +241,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
         file_number = newTip->GetBlockPos().nFile;
         Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
     }
-    UnlinkPrunedFiles({file_number});
+    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
 
     // Verify ScanForWalletTransactions scans no blocks.
     {
@@ -279,7 +278,7 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
         file_number = oldTip->GetBlockPos().nFile;
         Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
     }
-    UnlinkPrunedFiles({file_number});
+    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
 
     // Verify importmulti RPC returns failure for a key whose creation time is
     // before the missing block, and success for a key whose creation time is
@@ -751,7 +750,7 @@ BOOST_FIXTURE_TEST_CASE(BasicOutputTypesTest, ListCoinsTestingSetup)
 //! default regtest parameters place far beyond the pinned fixture chains. The
 //! same chain as the evo tests: activation at 109, tip at 108.
 struct AssetLockTestingSetup : public TestChainSetup {
-    AssetLockTestingSetup() : TestChainSetup{107, CBaseChainParams::REGTEST, {"-dip3params=109:500"}}
+    AssetLockTestingSetup() : TestChainSetup{107, ChainType::REGTEST, {"-dip3params=109:500"}}
     {
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
         wallet = CreateSyncedWallet(*m_node.chain, *Assert(m_node.chainman), coinbaseKey);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6e1e581e1f98..c30ab4bb65ea 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -4,11 +4,13 @@
 // 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 <wallet/wallet.h>
 
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <crypto/common.h>
@@ -37,7 +39,6 @@
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 #ifdef USE_BDB
@@ -76,9 +77,9 @@ static isminetype InputIsMine(const CWallet& wallet, const CTxIn& txin) EXCLUSIV
 
 bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
 {
-    util::SettingsValue setting_value = chain.getRwSetting("wallet");
+    common::SettingsValue setting_value = chain.getRwSetting("wallet");
     if (!setting_value.isArray()) setting_value.setArray();
-    for (const util::SettingsValue& value : setting_value.getValues()) {
+    for (const common::SettingsValue& value : setting_value.getValues()) {
         if (value.isStr() && value.get_str() == wallet_name) return true;
     }
     setting_value.push_back(wallet_name);
@@ -87,10 +88,10 @@ bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
 
 bool RemoveWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
 {
-    util::SettingsValue setting_value = chain.getRwSetting("wallet");
+    common::SettingsValue setting_value = chain.getRwSetting("wallet");
     if (!setting_value.isArray()) return true;
-    util::SettingsValue new_value(util::SettingsValue::VARR);
-    for (const util::SettingsValue& value : setting_value.getValues()) {
+    common::SettingsValue new_value(common::SettingsValue::VARR);
+    for (const common::SettingsValue& value : setting_value.getValues()) {
         if (!value.isStr() || value.get_str() != wallet_name) new_value.push_back(value);
     }
     if (new_value.size() == setting_value.size()) return true;
@@ -2517,7 +2518,7 @@ bool CWallet::SignSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std
 bool CWallet::SignGovernanceVote(const CKeyID& keyID, CGovernanceVote& vote) const
 {
     // Special implementation for testnet (Harden Spork6 that has not been deployed to other networks)
-    if (Params().NetworkIDString() == CBaseChainParams::TESTNET) {
+    if (Params().GetChainType() == ChainType::TESTNET) {
         std::vector<unsigned char> signature;
         if (!SignSpecialTxPayload(vote.GetSignatureHash(), keyID, signature)) {
             LogPrintf("SignGovernanceVote -- SignHash() failed\n");
@@ -3245,7 +3246,7 @@ bool CWallet::SetAddressPreviouslySpent(WalletBatch& batch, const CTxDestination
         return false;
 
     if (!used) {
-        if (auto* data{util::FindKey(m_address_book, dest)}) data->previously_spent = false;
+        if (auto* data{common::FindKey(m_address_book, dest)}) data->previously_spent = false;
         return batch.WriteAddressPreviouslySpent(dest, false);
     }
 
@@ -3265,7 +3266,7 @@ void CWallet::LoadAddressReceiveRequest(const CTxDestination& dest, const std::s
 
 bool CWallet::IsAddressPreviouslySpent(const CTxDestination& dest) const
 {
-    if (auto* data{util::FindKey(m_address_book, dest)}) return data->previously_spent;
+    if (auto* data{common::FindKey(m_address_book, dest)}) return data->previously_spent;
     return false;
 }
 
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 4d062fe4643f..b8e7af1a7e26 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -10,13 +10,13 @@
 
 #include <wallet/walletdb.h>
 
+#include <common/system.h>
 #include <governance/common.h>
 #include <key_io.h>
 #include <protocol.h>
 #include <serialize.h>
 #include <sync.h>
 #include <util/fs.h>
-#include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 #ifdef USE_BDB
diff --git a/src/wallet/wallettool.cpp b/src/wallet/wallettool.cpp
index c070d3aec8e7..d06ffad83266 100644
--- a/src/wallet/wallettool.cpp
+++ b/src/wallet/wallettool.cpp
@@ -8,9 +8,10 @@
 
 #include <wallet/wallettool.h>
 
+#include <common/args.h>
+#include <common/system.h>
 #include <util/fs.h>
 #include <util/translation.h>
-#include <util/system.h>
 #include <wallet/dump.h>
 #include <wallet/salvage.h>
 #include <wallet/wallet.h>
diff --git a/src/wallet/walletutil.cpp b/src/wallet/walletutil.cpp
index 21b9055a9ed9..b05253718fb9 100644
--- a/src/wallet/walletutil.cpp
+++ b/src/wallet/walletutil.cpp
@@ -4,8 +4,8 @@
 
 #include <wallet/walletutil.h>
 
+#include <common/args.h>
 #include <logging.h>
-#include <util/system.h>
 
 namespace wallet {
 fs::path GetWalletDir()
diff --git a/src/warnings.cpp b/src/warnings.cpp
index 8b46f409c894..716ffd1add04 100644
--- a/src/warnings.cpp
+++ b/src/warnings.cpp
@@ -9,9 +9,9 @@
 
 #include <warnings.h>
 
+#include <common/system.h>
 #include <sync.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <hash.h>
 
diff --git a/src/zmq/zmqabstractnotifier.h b/src/zmq/zmqabstractnotifier.h
index 32569a3a542b..2cee0d4b8b89 100644
--- a/src/zmq/zmqabstractnotifier.h
+++ b/src/zmq/zmqabstractnotifier.h
@@ -6,6 +6,7 @@
 #define BITCOIN_ZMQ_ZMQABSTRACTNOTIFIER_H
 
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -28,7 +29,7 @@ class CRecoveredSig;
 } // namespace llmq
 
 using CTransactionRef = std::shared_ptr<const CTransaction>;
-using CZMQNotifierFactory = std::unique_ptr<CZMQAbstractNotifier> (*)();
+using CZMQNotifierFactory = std::function<std::unique_ptr<CZMQAbstractNotifier>()>;
 
 class CZMQAbstractNotifier
 {
diff --git a/src/zmq/zmqnotificationinterface.cpp b/src/zmq/zmqnotificationinterface.cpp
index eb93eeed3aa9..8dcfc4986d44 100644
--- a/src/zmq/zmqnotificationinterface.cpp
+++ b/src/zmq/zmqnotificationinterface.cpp
@@ -4,11 +4,11 @@
 
 #include <zmq/zmqnotificationinterface.h>
 
+#include <common/args.h>
 #include <logging.h>
 #include <netbase.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <util/system.h>
 #include <validationinterface.h>
 #include <zmq/zmqabstractnotifier.h>
 #include <zmq/zmqpublishnotifier.h>
@@ -40,7 +40,7 @@ std::list<const CZMQAbstractNotifier*> CZMQNotificationInterface::GetActiveNotif
     return result;
 }
 
-std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create()
+std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index)
 {
     std::map<std::string, CZMQNotifierFactory> factories;
     factories["pubhashblock"] = CZMQAbstractNotifier::Create<CZMQPublishHashBlockNotifier>;
@@ -51,9 +51,15 @@ std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create()
     factories["pubhashgovernanceobject"] = CZMQAbstractNotifier::Create<CZMQPublishHashGovernanceObjectNotifier>;
     factories["pubhashinstantsenddoublespend"] = CZMQAbstractNotifier::Create<CZMQPublishHashInstantSendDoubleSpendNotifier>;
     factories["pubhashrecoveredsig"] = CZMQAbstractNotifier::Create<CZMQPublishHashRecoveredSigNotifier>;
-    factories["pubrawblock"] = CZMQAbstractNotifier::Create<CZMQPublishRawBlockNotifier>;
-    factories["pubrawchainlock"] = CZMQAbstractNotifier::Create<CZMQPublishRawChainLockNotifier>;
-    factories["pubrawchainlocksig"] = CZMQAbstractNotifier::Create<CZMQPublishRawChainLockSigNotifier>;
+    factories["pubrawblock"] = [&get_block_by_index]() -> std::unique_ptr<CZMQAbstractNotifier> {
+        return std::make_unique<CZMQPublishRawBlockNotifier>(get_block_by_index);
+    };
+    factories["pubrawchainlock"] = [&get_block_by_index]() -> std::unique_ptr<CZMQAbstractNotifier> {
+        return std::make_unique<CZMQPublishRawChainLockNotifier>(get_block_by_index);
+    };
+    factories["pubrawchainlocksig"] = [&get_block_by_index]() -> std::unique_ptr<CZMQAbstractNotifier> {
+        return std::make_unique<CZMQPublishRawChainLockSigNotifier>(get_block_by_index);
+    };
     factories["pubrawtx"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionNotifier>;
     factories["pubrawtxlock"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionLockNotifier>;
     factories["pubrawtxlocksig"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionLockSigNotifier>;
diff --git a/src/zmq/zmqnotificationinterface.h b/src/zmq/zmqnotificationinterface.h
index 199d5647d072..8858dfc00349 100644
--- a/src/zmq/zmqnotificationinterface.h
+++ b/src/zmq/zmqnotificationinterface.h
@@ -9,6 +9,7 @@
 #include <validationinterface.h>
 
 #include <cstdint>
+#include <functional>
 #include <list>
 #include <memory>
 
@@ -23,7 +24,7 @@ class CZMQNotificationInterface final : public CValidationInterface
 
     std::list<const CZMQAbstractNotifier*> GetActiveNotifiers() const;
 
-    static std::unique_ptr<CZMQNotificationInterface> Create();
+    static std::unique_ptr<CZMQNotificationInterface> Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index);
 
 protected:
     bool Initialize();
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
index 4adbc9fecd6f..011c31ead794 100644
--- a/src/zmq/zmqpublishnotifier.cpp
+++ b/src/zmq/zmqpublishnotifier.cpp
@@ -46,8 +46,6 @@ namespace Consensus {
 struct Params;
 }
 
-using node::ReadBlockFromDisk;
-
 static std::multimap<std::string, CZMQAbstractPublishNotifier*> mapPublishNotifiers;
 
 static const char *MSG_HASHBLOCK     = "hashblock";
@@ -329,10 +327,9 @@ bool CZMQPublishRawBlockNotifier::NotifyBlock(const CBlockIndex *pindex)
 {
     LogPrint(BCLog::ZMQ, "Publish rawblock %s to %s\n", pindex->GetBlockHash().GetHex(), this->address);
 
-    const Consensus::Params& consensusParams = Params().GetConsensus();
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     CBlock block;
-    if(!ReadBlockFromDisk(block, pindex, consensusParams)) {
+    if (!m_get_block_by_index(block, *pindex)) {
         zmqError("Can't read block from disk");
         return false;
     }
@@ -346,12 +343,11 @@ bool CZMQPublishRawChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex,
 {
     LogPrint(BCLog::ZMQ, "Publish rawchainlock %s to %s\n", pindex->GetBlockHash().GetHex(), this->address);
 
-    const Consensus::Params& consensusParams = Params().GetConsensus();
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     {
         LOCK(cs_main);
         CBlock block;
-        if(!ReadBlockFromDisk(block, pindex, consensusParams))
+        if (!m_get_block_by_index(block, *pindex))
         {
             zmqError("Can't read block from disk");
             return false;
@@ -367,12 +363,11 @@ bool CZMQPublishRawChainLockSigNotifier::NotifyChainLock(const CBlockIndex *pind
 {
     LogPrint(BCLog::ZMQ, "Publish rawchainlocksig %s to %s\n", pindex->GetBlockHash().GetHex(), this->address);
 
-    const Consensus::Params& consensusParams = Params().GetConsensus();
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     {
         LOCK(cs_main);
         CBlock block;
-        if(!ReadBlockFromDisk(block, pindex, consensusParams))
+        if (!m_get_block_by_index(block, *pindex))
         {
             zmqError("Can't read block from disk");
             return false;
diff --git a/src/zmq/zmqpublishnotifier.h b/src/zmq/zmqpublishnotifier.h
index 704c92992abb..b98909847cf6 100644
--- a/src/zmq/zmqpublishnotifier.h
+++ b/src/zmq/zmqpublishnotifier.h
@@ -9,7 +9,9 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 
+class CBlock;
 class CBlockIndex;
 class CDeterministicMNList;
 class CGovernanceVote;
@@ -89,19 +91,34 @@ class CZMQPublishHashRecoveredSigNotifier : public CZMQAbstractPublishNotifier
 
 class CZMQPublishRawBlockNotifier : public CZMQAbstractPublishNotifier
 {
+private:
+    const std::function<bool(CBlock&, const CBlockIndex&)> m_get_block_by_index;
+
 public:
+    CZMQPublishRawBlockNotifier(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index)
+        : m_get_block_by_index{std::move(get_block_by_index)} {}
     bool NotifyBlock(const CBlockIndex *pindex) override;
 };
 
 class CZMQPublishRawChainLockNotifier : public CZMQAbstractPublishNotifier
 {
+private:
+    const std::function<bool(CBlock&, const CBlockIndex&)> m_get_block_by_index;
+
 public:
+    CZMQPublishRawChainLockNotifier(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index)
+        : m_get_block_by_index{std::move(get_block_by_index)} {}
     bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 };
 
 class CZMQPublishRawChainLockSigNotifier : public CZMQAbstractPublishNotifier
 {
+private:
+    const std::function<bool(CBlock&, const CBlockIndex&)> m_get_block_by_index;
+
 public:
+    CZMQPublishRawChainLockSigNotifier(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index)
+        : m_get_block_by_index{std::move(get_block_by_index)} {}
     bool NotifyChainLock(const CBlockIndex *pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
 };
 
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 0ea1371a98e6..a8912268946b 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -12,7 +12,7 @@
 import sys
 
 EXPECTED_BITCOIN_CIRCULAR_DEPENDENCIES = (
-    "chainparamsbase -> util/system -> chainparamsbase",
+    "chainparamsbase -> common/args -> chainparamsbase",
     "node/blockstorage -> validation -> node/blockstorage",
     "node/utxo_snapshot -> validation -> node/utxo_snapshot",
     "qt/addresstablemodel -> qt/walletmodel -> qt/addresstablemodel",