diff --git a/doc/design/assumeutxo.md b/doc/design/assumeutxo.md
index 667b3deda0b5..e9562f87a1a3 100644
--- a/doc/design/assumeutxo.md
+++ b/doc/design/assumeutxo.md
@@ -41,7 +41,7 @@ be of use.
 
 Chainstate within the system goes through a number of phases when UTXO snapshots are
 used, as managed by `ChainstateManager`. At various points there can be multiple
-`CChainState` objects in existence to facilitate both maintaining the network tip and
+`Chainstate` objects in existence to facilitate both maintaining the network tip and
 performing historical validation of the assumed-valid chain.
 
 It is worth noting that though there are multiple separate chainstates, those
@@ -53,7 +53,7 @@ data.
 
 ### "Normal" operation via initial block download
 
-`ChainstateManager` manages a single CChainState object, for which
+`ChainstateManager` manages a single Chainstate object, for which
 `m_snapshot_blockhash` is null. This chainstate is (maybe obviously)
 considered active. This is the "traditional" mode of operation for dashd.
 
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index c343f3a7e007..61025728bef1 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -1034,7 +1034,7 @@ void CTxMemPool::UpdateTransactionsFromBlock(...)
 
 ```C++
 // validation.h
-class CChainState
+class Chainstate
 {
 protected:
     ...
@@ -1055,7 +1055,7 @@ public:
 }
 
 // validation.cpp
-bool CChainState::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
+bool Chainstate::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
 {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
diff --git a/src/Makefile.am b/src/Makefile.am
index a0eca537b48d..99627e98a932 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -244,7 +244,6 @@ BITCOIN_CORE_H = \
   gsl/pointers.h \
   flat-database.h \
   flatfile.h \
-  fs.h \
   httprpc.h \
   httpserver.h \
   i2p.h \
@@ -398,6 +397,8 @@ BITCOIN_CORE_H = \
   util/error.h \
   util/fastrange.h \
   util/fees.h \
+  util/fs.h \
+  util/fs_helpers.h \
   util/golombrice.h \
   util/hasher.h \
   util/hash_type.h \
@@ -978,7 +979,6 @@ libbitcoin_util_a_SOURCES = \
   support/lockedpool.cpp \
   chainparamsbase.cpp \
   clientversion.cpp \
-  fs.cpp \
   interfaces/echo.cpp \
   interfaces/handler.cpp \
   interfaces/init.cpp \
@@ -996,6 +996,8 @@ libbitcoin_util_a_SOURCES = \
   util/edge.cpp \
   util/error.cpp \
   util/fees.cpp \
+  util/fs.cpp \
+  util/fs_helpers.cpp \
   util/hasher.cpp \
   util/getuniquepath.cpp \
   util/sock.cpp \
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index 83bc6192ff7b..823bbc7fe009 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -8,7 +8,8 @@
 #include <addrman.h>
 #include <chainparams.h>
 #include <clientversion.h>
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <hash.h>
 #include <logging/timer.h>
 #include <netbase.h>
diff --git a/src/addrdb.h b/src/addrdb.h
index 911b791b7170..2d71f7456e74 100644
--- a/src/addrdb.h
+++ b/src/addrdb.h
@@ -6,9 +6,9 @@
 #ifndef BITCOIN_ADDRDB_H
 #define BITCOIN_ADDRDB_H
 
-#include <fs.h>
 #include <net_types.h> // For banmap_t
 #include <univalue.h>
+#include <util/fs.h>
 
 #include <memory>
 #include <optional>
diff --git a/src/banman.h b/src/banman.h
index c968fd99a2c0..77d78966a58d 100644
--- a/src/banman.h
+++ b/src/banman.h
@@ -7,9 +7,9 @@
 
 #include <addrdb.h>
 #include <common/bloom.h>
-#include <fs.h>
 #include <net_types.h> // For banmap_t
 #include <sync.h>
+#include <util/fs.h>
 
 #include <chrono>
 #include <cstdint>
diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp
index ae017833ce6b..de8eacfa9570 100644
--- a/src/bench/bench.cpp
+++ b/src/bench/bench.cpp
@@ -4,8 +4,8 @@
 
 #include <bench/bench.h>
 
-#include <fs.h>
 #include <test/util/setup_common.h>
+#include <util/fs.h>
 #include <util/string.h>
 
 #include <algorithm>
diff --git a/src/bench/bench.h b/src/bench/bench.h
index 63e1bf67e21e..d3fba1e28c41 100644
--- a/src/bench/bench.h
+++ b/src/bench/bench.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_BENCH_BENCH_H
 #define BITCOIN_BENCH_BENCH_H
 
-#include <fs.h>
+#include <util/fs.h>
 #include <util/macros.h>
 
 #include <chrono>
diff --git a/src/bench/bench_bitcoin.cpp b/src/bench/bench_bitcoin.cpp
index 4db5412e16d6..c34949264cc2 100644
--- a/src/bench/bench_bitcoin.cpp
+++ b/src/bench/bench_bitcoin.cpp
@@ -8,7 +8,7 @@
 #include <clientversion.h>
 #include <crypto/sha256.h>
 #include <crypto/x11/dispatch.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
diff --git a/src/bench/load_external.cpp b/src/bench/load_external.cpp
index 150654a095ca..ec97be45ff1e 100644
--- a/src/bench/load_external.cpp
+++ b/src/bench/load_external.cpp
@@ -48,7 +48,7 @@ static void LoadExternalBlockFile(benchmark::Bench& bench)
         fclose(file);
     }
 
-    CChainState& chainstate{testing_setup->m_node.chainman->ActiveChainstate()};
+    Chainstate& chainstate{testing_setup->m_node.chainman->ActiveChainstate()};
     std::multimap<uint256, FlatFilePos> blocks_with_unknown_parent;
     FlatFilePos pos;
     bench.run([&] {
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index a1dfb9e7d374..47b569f1ae19 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -13,7 +13,7 @@
 #include <consensus/consensus.h>
 #include <core_io.h>
 #include <key_io.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp
index 9a63ee387ae2..3711037bfddd 100644
--- a/src/chainlock/signing.cpp
+++ b/src/chainlock/signing.cpp
@@ -20,7 +20,7 @@
 using node::ReadBlockFromDisk;
 
 namespace chainlock {
-ChainLockSigner::ChainLockSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks,
+ChainLockSigner::ChainLockSigner(Chainstate& chainstate, const chainlock::Chainlocks& chainlocks,
                                  ChainlockHandler& clhandler, const llmq::CInstantSendManager& isman,
                                  const llmq::CQuorumManager& qman, llmq::CSigningManager& sigman,
                                  llmq::CSigSharesManager& shareman, const CMasternodeSync& mn_sync) :
diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h
index f19659727f72..56287e1805fb 100644
--- a/src/chainlock/signing.h
+++ b/src/chainlock/signing.h
@@ -26,7 +26,7 @@ class ChainlockHandler;
 class ChainLockSigner final : public llmq::CRecoveredSigsListener, public CValidationInterface
 {
 private:
-    CChainState& m_chainstate;
+    Chainstate& m_chainstate;
     const chainlock::Chainlocks& m_chainlocks;
     ChainlockHandler& m_clhandler;
     const llmq::CInstantSendManager& m_isman;
@@ -59,7 +59,7 @@ class ChainLockSigner final : public llmq::CRecoveredSigsListener, public CValid
     ChainLockSigner() = delete;
     ChainLockSigner(const ChainLockSigner&) = delete;
     ChainLockSigner& operator=(const ChainLockSigner&) = delete;
-    explicit ChainLockSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks,
+    explicit ChainLockSigner(Chainstate& chainstate, const chainlock::Chainlocks& chainlocks,
                              ChainlockHandler& clhandler, const llmq::CInstantSendManager& isman,
                              const llmq::CQuorumManager& qman, llmq::CSigningManager& sigman,
                              llmq::CSigSharesManager& shareman, const CMasternodeSync& mn_sync);
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 6474cbd708bb..1c767ea2d040 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -19,6 +19,7 @@
 #include <netmessagemaker.h>
 #include <shutdown.h>
 #include <util/check.h>
+#include <util/fs_helpers.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/translation.h>
@@ -55,7 +56,8 @@ CCoinJoinClientManager::CCoinJoinClientManager(const std::shared_ptr<wallet::CWa
 
 CCoinJoinClientManager::~CCoinJoinClientManager() = default;
 
-void CCoinJoinClientManager::ProcessMessage(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv)
+void CCoinJoinClientManager::ProcessMessage(CNode& peer, Chainstate& active_chainstate, CConnman& connman,
+                                            const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv)
 {
     if (!CCoinJoinClientOptions::IsEnabled()) return;
     if (!m_mn_sync.IsBlockchainSynced()) return;
@@ -89,7 +91,7 @@ CCoinJoinClientSession::CCoinJoinClientSession(const std::shared_ptr<CWallet>& w
     m_isman{isman}
 {}
 
-void CCoinJoinClientSession::ProcessMessage(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv)
+void CCoinJoinClientSession::ProcessMessage(CNode& peer, Chainstate& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv)
 {
     if (!CCoinJoinClientOptions::IsEnabled()) return;
     if (!m_mn_sync.IsBlockchainSynced()) return;
@@ -444,7 +446,7 @@ void CCoinJoinClientSession::ProcessPoolStateUpdate(CCoinJoinStatusUpdate psssup
 // check it to make sure it's what we want, then sign it if we agree.
 // If we refuse to sign, it's possible we'll be charged collateral
 //
-bool CCoinJoinClientSession::SignFinalTransaction(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, const CTransaction& finalTransactionNew)
+bool CCoinJoinClientSession::SignFinalTransaction(CNode& peer, Chainstate& active_chainstate, CConnman& connman, const CTxMemPool& mempool, const CTransaction& finalTransactionNew)
 {
     if (!CCoinJoinClientOptions::IsEnabled()) return false;
 
@@ -1782,4 +1784,3 @@ void CCoinJoinClientManager::GetJsonInfo(UniValue& obj) const
     }
     obj.pushKV("sessions", arrSessions);
 }
-
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 3785d307099e..effd7f62e0c9 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -117,7 +117,7 @@ class CCoinJoinClientSession : public CCoinJoinBaseSession
     void CompletedTransaction(PoolMessage nMessageID);
 
     /// As a client, check and sign the final transaction
-    bool SignFinalTransaction(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, const CTransaction& finalTransactionNew) EXCLUSIVE_LOCKS_REQUIRED(!cs_coinjoin);
+    bool SignFinalTransaction(CNode& peer, Chainstate& active_chainstate, CConnman& connman, const CTxMemPool& mempool, const CTransaction& finalTransactionNew) EXCLUSIVE_LOCKS_REQUIRED(!cs_coinjoin);
 
     void RelayIn(const CCoinJoinEntry& entry, CConnman& connman) const;
 
@@ -128,7 +128,7 @@ class CCoinJoinClientSession : public CCoinJoinBaseSession
                                     CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
                                     const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman);
 
-    void ProcessMessage(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv);
+    void ProcessMessage(CNode& peer, Chainstate& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv);
 
     void UnlockCoins();
 
@@ -195,7 +195,7 @@ class CCoinJoinClientManager
                                     const llmq::CInstantSendManager& isman, CoinJoinQueueManager* queueman);
     ~CCoinJoinClientManager();
 
-    void ProcessMessage(CNode& peer, CChainState& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv) EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);
+    void ProcessMessage(CNode& peer, Chainstate& active_chainstate, CConnman& connman, const CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv) EXCLUSIVE_LOCKS_REQUIRED(!cs_deqsessions);
 
     bool StartMixing();
     void StopMixing();
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 010a81c877b7..947dc2ea40c7 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -199,7 +199,7 @@ std::string CCoinJoinBaseSession::GetStateString() const
     }
 }
 
-bool CCoinJoinBaseSession::IsValidInOuts(CChainState& active_chainstate, const llmq::CInstantSendManager& isman,
+bool CCoinJoinBaseSession::IsValidInOuts(Chainstate& active_chainstate, const llmq::CInstantSendManager& isman,
                                          const CTxMemPool& mempool, const std::vector<CTxIn>& vin,
                                          const std::vector<CTxOut>& vout, PoolMessage& nMessageIDRet,
                                          bool* fConsumeCollateralRet) const
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
index ea073f14f79e..e39387c2edb8 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -25,7 +25,7 @@
 
 #include <univalue.h>
 
-class CChainState;
+class Chainstate;
 class CBLSPublicKey;
 class CBlockIndex;
 class ChainstateManager;
@@ -304,7 +304,7 @@ class CCoinJoinBaseSession
 
     virtual void SetNull() EXCLUSIVE_LOCKS_REQUIRED(cs_coinjoin);
 
-    bool IsValidInOuts(CChainState& active_chainstate, const llmq::CInstantSendManager& isman,
+    bool IsValidInOuts(Chainstate& active_chainstate, const llmq::CInstantSendManager& isman,
                        const CTxMemPool& mempool, const std::vector<CTxIn>& vin, const std::vector<CTxOut>& vout,
                        PoolMessage& nMessageIDRet, bool* fConsumeCollateralRet) const;
 
diff --git a/src/coinjoin/walletman.cpp b/src/coinjoin/walletman.cpp
index a54ac93795b4..42c70b30e24f 100644
--- a/src/coinjoin/walletman.cpp
+++ b/src/coinjoin/walletman.cpp
@@ -40,7 +40,7 @@ class CJWalletManagerImpl final : public CJWalletManager
 public:
     bool hasQueue(const uint256& hash) const override;
     CCoinJoinClientManager* getClient(const std::string& name) override EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet_manager_map);
-    MessageProcessingResult processMessage(CNode& peer, CChainState& chainstate, CConnman& connman, CTxMemPool& mempool,
+    MessageProcessingResult processMessage(CNode& peer, Chainstate& chainstate, CConnman& connman, CTxMemPool& mempool,
                                            std::string_view msg_type, CDataStream& vRecv) override EXCLUSIVE_LOCKS_REQUIRED(!cs_ProcessDSQueue, !cs_wallet_manager_map);
     std::optional<CCoinJoinQueue> getQueueFromHash(const uint256& hash) const override;
     std::optional<int> getQueueSize() const override;
@@ -202,7 +202,7 @@ void CJWalletManagerImpl::DoMaintenance(CConnman& connman)
     }
 }
 
-MessageProcessingResult CJWalletManagerImpl::processMessage(CNode& pfrom, CChainState& chainstate, CConnman& connman,
+MessageProcessingResult CJWalletManagerImpl::processMessage(CNode& pfrom, Chainstate& chainstate, CConnman& connman,
                                                             CTxMemPool& mempool, std::string_view msg_type,
                                                             CDataStream& vRecv)
 {
diff --git a/src/coinjoin/walletman.h b/src/coinjoin/walletman.h
index 720a4bdf2f81..9d79f4f4f78f 100644
--- a/src/coinjoin/walletman.h
+++ b/src/coinjoin/walletman.h
@@ -14,7 +14,7 @@
 #include <string_view>
 
 class CBlockIndex;
-class CChainState;
+class Chainstate;
 class CCoinJoinClientManager;
 class CCoinJoinQueue;
 class CConnman;
@@ -48,7 +48,7 @@ class CJWalletManager : public CValidationInterface
 public:
     virtual bool hasQueue(const uint256& hash) const = 0;
     virtual CCoinJoinClientManager* getClient(const std::string& name) = 0;
-    virtual MessageProcessingResult processMessage(CNode& peer, CChainState& chainstate, CConnman& connman,
+    virtual MessageProcessingResult processMessage(CNode& peer, Chainstate& chainstate, CConnman& connman,
                                                    CTxMemPool& mempool, std::string_view msg_type, CDataStream& vRecv) = 0;
     virtual std::optional<CCoinJoinQueue> getQueueFromHash(const uint256& hash) const = 0;
     virtual std::optional<int> getQueueSize() const = 0;
diff --git a/src/dbwrapper.cpp b/src/dbwrapper.cpp
index c4d9cf615faa..f4320e4b47dc 100644
--- a/src/dbwrapper.cpp
+++ b/src/dbwrapper.cpp
@@ -4,7 +4,8 @@
 
 #include <dbwrapper.h>
 
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <logging.h>
 #include <random.h>
 #include <util/strencodings.h>
diff --git a/src/dbwrapper.h b/src/dbwrapper.h
index 9f04c8523266..0daf932d0522 100644
--- a/src/dbwrapper.h
+++ b/src/dbwrapper.h
@@ -7,11 +7,11 @@
 
 #include <assert.h>
 #include <clientversion.h>
-#include <fs.h>
 #include <logging.h>
 #include <serialize.h>
 #include <span.h>
 #include <streams.h>
+#include <util/fs.h>
 
 #include <sys/types.h>
 
diff --git a/src/flat-database.h b/src/flat-database.h
index 3fa2e512c445..333cf2d4e7ba 100644
--- a/src/flat-database.h
+++ b/src/flat-database.h
@@ -7,7 +7,7 @@
 
 #include <clientversion.h>
 #include <chainparams.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <hash.h>
 #include <streams.h>
 #include <util/system.h>
diff --git a/src/flatfile.cpp b/src/flatfile.cpp
index 0fecf4f50499..971db27f364d 100644
--- a/src/flatfile.cpp
+++ b/src/flatfile.cpp
@@ -8,7 +8,7 @@
 #include <flatfile.h>
 #include <logging.h>
 #include <tinyformat.h>
-#include <util/system.h>
+#include <util/fs_helpers.h>
 
 FlatFileSeq::FlatFileSeq(fs::path dir, const char* prefix, size_t chunk_size) :
     m_dir(std::move(dir)),
diff --git a/src/flatfile.h b/src/flatfile.h
index 9c0a1541eabf..44b7c5ef9f51 100644
--- a/src/flatfile.h
+++ b/src/flatfile.h
@@ -8,8 +8,8 @@
 
 #include <string>
 
-#include <fs.h>
 #include <serialize.h>
+#include <util/fs.h>
 
 struct FlatFilePos
 {
diff --git a/src/i2p.cpp b/src/i2p.cpp
index 14f8b39ccd70..50d6d637c11d 100644
--- a/src/i2p.cpp
+++ b/src/i2p.cpp
@@ -6,7 +6,6 @@
 #include <compat/compat.h>
 #include <compat/endian.h>
 #include <crypto/sha256.h>
-#include <fs.h>
 #include <i2p.h>
 #include <logging.h>
 #include <netaddress.h>
@@ -14,6 +13,7 @@
 #include <random.h>
 #include <sync.h>
 #include <tinyformat.h>
+#include <util/fs.h>
 #include <util/readwritefile.h>
 #include <util/sock.h>
 #include <util/spanparsing.h>
diff --git a/src/i2p.h b/src/i2p.h
index c620a5442181..834f1e5218cb 100644
--- a/src/i2p.h
+++ b/src/i2p.h
@@ -6,10 +6,10 @@
 #define BITCOIN_I2P_H
 
 #include <compat/compat.h>
-#include <fs.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <sync.h>
+#include <util/fs.h>
 #include <util/sock.h>
 #include <util/threadinterrupt.h>
 
diff --git a/src/index/base.cpp b/src/index/base.cpp
index d585cac6dd53..e508e6acb391 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -355,7 +355,7 @@ void BaseIndex::Interrupt()
     m_interrupt();
 }
 
-bool BaseIndex::Start(CChainState& active_chainstate)
+bool BaseIndex::Start(Chainstate& active_chainstate)
 {
     m_chainstate = &active_chainstate;
     // Need to register this ValidationInterface before running Init(), so that
diff --git a/src/index/base.h b/src/index/base.h
index 8c4fc98b68b2..416717ebf1b5 100644
--- a/src/index/base.h
+++ b/src/index/base.h
@@ -13,7 +13,7 @@
 
 class CBlock;
 class CBlockIndex;
-class CChainState;
+class Chainstate;
 
 struct IndexSummary {
     std::string name;
@@ -85,7 +85,7 @@ class BaseIndex : public CValidationInterface
     virtual bool AllowPrune() const = 0;
 
 protected:
-    CChainState* m_chainstate{nullptr};
+    Chainstate* m_chainstate{nullptr};
 
     void BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
 
@@ -130,7 +130,7 @@ class BaseIndex : public CValidationInterface
 
     /// Start initializes the sync state and registers the instance as a
     /// ValidationInterface so that it stays in sync with blockchain updates.
-    [[nodiscard]] bool Start(CChainState& active_chainstate);
+    [[nodiscard]] bool Start(Chainstate& active_chainstate);
 
     /// Stops the instance from staying in sync with blockchain updates.
     void Stop();
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index 5449a93b0954..712b7f408dd1 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -9,6 +9,7 @@
 #include <index/blockfilterindex.h>
 #include <node/blockstorage.h>
 #include <serialize.h>
+#include <util/fs_helpers.h>
 #include <util/system.h>
 
 using node::UndoReadFromDisk;
diff --git a/src/init.cpp b/src/init.cpp
index 113bd4c9f025..94636d382270 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -19,7 +19,8 @@
 #include <context.h>
 #include <consensus/amount.h>
 #include <deploymentstatus.h>
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <hash.h>
 #include <httpserver.h>
 #include <httprpc.h>
@@ -338,7 +339,7 @@ void PrepareShutdown(NodeContext& node)
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
     if (node.chainman) {
         LOCK(cs_main);
-        for (CChainState* chainstate : node.chainman->GetAll()) {
+        for (Chainstate* chainstate : node.chainman->GetAll()) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
             }
@@ -396,7 +397,7 @@ void PrepareShutdown(NodeContext& node)
 
     if (node.chainman) {
         LOCK(cs_main);
-        for (CChainState* chainstate : node.chainman->GetAll()) {
+        for (Chainstate* chainstate : node.chainman->GetAll()) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
                 chainstate->ResetCoinsViews();
@@ -2317,7 +2318,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     if (fPruneMode) {
         if (!fReindex) {
             LOCK(cs_main);
-            for (CChainState* chainstate : chainman.GetAll()) {
+            for (Chainstate* chainstate : chainman.GetAll()) {
                 uiInterface.InitMessage(_("Pruning blockstore…").translated);
                 chainstate->PruneAndFlush();
             }
diff --git a/src/init/common.cpp b/src/init/common.cpp
index 21d8e337b127..5b70906b2028 100644
--- a/src/init/common.cpp
+++ b/src/init/common.cpp
@@ -10,7 +10,7 @@
 #include <clientversion.h>
 #include <crypto/sha256.h>
 #include <crypto/x11/dispatch.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <key.h>
 #include <logging.h>
 #include <node/interface_ui.h>
diff --git a/src/instantsend/net_instantsend.cpp b/src/instantsend/net_instantsend.cpp
index c25d771a5833..dbaff1fb712c 100644
--- a/src/instantsend/net_instantsend.cpp
+++ b/src/instantsend/net_instantsend.cpp
@@ -37,7 +37,7 @@ constexpr int OLD_ACTIVE_SET_FAILURE_MISBEHAVIOR_SCORE{20};
 constexpr auto WORK_THREAD_SLEEP_INTERVAL{std::chrono::milliseconds{100}};
 } // namespace
 
-static std::optional<int> GetBlockHeight(llmq::CInstantSendManager& is_manager, const CChainState& chainstate,
+static std::optional<int> GetBlockHeight(llmq::CInstantSendManager& is_manager, const Chainstate& chainstate,
                                          const uint256& hash)
 {
     if (hash.IsNull()) {
diff --git a/src/instantsend/net_instantsend.h b/src/instantsend/net_instantsend.h
index d5b35e89eb2a..a6c29d7a6769 100644
--- a/src/instantsend/net_instantsend.h
+++ b/src/instantsend/net_instantsend.h
@@ -14,7 +14,7 @@
 #include <thread>
 #include <vector>
 
-class CChainState;
+class Chainstate;
 
 namespace Consensus {
 struct LLMQParams;
@@ -44,7 +44,7 @@ class NetInstantSend final : public NetHandler, public CValidationInterface
 public:
     NetInstantSend(PeerManagerInternal* peer_manager, llmq::CInstantSendManager& is_manager,
                    instantsend::InstantSendSigner* signer, llmq::CSigningManager& sigman, llmq::CQuorumManager& qman,
-                   const chainlock::Chainlocks& chainlocks, CChainState& chainstate, CTxMemPool& mempool,
+                   const chainlock::Chainlocks& chainlocks, Chainstate& chainstate, CTxMemPool& mempool,
                    const CMasternodeSync& mn_sync) :
         NetHandler(peer_manager),
         m_is_manager{is_manager},
@@ -113,7 +113,7 @@ class NetInstantSend final : public NetHandler, public CValidationInterface
     llmq::CSigningManager& m_sigman;
     llmq::CQuorumManager& m_qman;
     const chainlock::Chainlocks& m_chainlocks;
-    CChainState& m_chainstate;
+    Chainstate& m_chainstate;
     CTxMemPool& m_mempool;
     const CMasternodeSync& m_mn_sync;
 
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 7c46f8d389aa..267debe29bd3 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -30,7 +30,7 @@ using node::fReindex;
 using node::GetTransaction;
 
 namespace instantsend {
-InstantSendSigner::InstantSendSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks,
+InstantSendSigner::InstantSendSigner(Chainstate& chainstate, const chainlock::Chainlocks& chainlocks,
                                      llmq::CInstantSendManager& isman, llmq::CSigningManager& sigman,
                                      llmq::CSigSharesManager& shareman, llmq::CQuorumManager& qman,
                                      CSporkManager& sporkman, CTxMemPool& mempool, const CMasternodeSync& mn_sync) :
diff --git a/src/instantsend/signing.h b/src/instantsend/signing.h
index 7202bd2daf80..fe06d2aa7c45 100644
--- a/src/instantsend/signing.h
+++ b/src/instantsend/signing.h
@@ -33,7 +33,7 @@ namespace instantsend {
 class InstantSendSigner final : public llmq::CRecoveredSigsListener
 {
 private:
-    CChainState& m_chainstate;
+    Chainstate& m_chainstate;
     const chainlock::Chainlocks& m_chainlocks;
     llmq::CInstantSendManager& m_isman;
     llmq::CSigningManager& m_sigman;
@@ -66,7 +66,7 @@ class InstantSendSigner final : public llmq::CRecoveredSigsListener
     InstantSendSigner() = delete;
     InstantSendSigner(const InstantSendSigner&) = delete;
     InstantSendSigner& operator=(const InstantSendSigner&) = delete;
-    explicit InstantSendSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks,
+    explicit InstantSendSigner(Chainstate& chainstate, const chainlock::Chainlocks& chainlocks,
                                llmq::CInstantSendManager& isman, llmq::CSigningManager& sigman,
                                llmq::CSigSharesManager& shareman, llmq::CQuorumManager& qman, CSporkManager& sporkman,
                                CTxMemPool& mempool, const CMasternodeSync& mn_sync);
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 134180f3728a..48f11e615a28 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -6,7 +6,7 @@
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <consensus/amount.h>          // For CAmount
-#include <fs.h>
+#include <util/fs.h>
 #include <governance/common.h>
 #include <interfaces/chain.h>          // For ChainClient
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
diff --git a/src/ipc/interfaces.cpp b/src/ipc/interfaces.cpp
index ee0d4123ceb5..49ba55d98d74 100644
--- a/src/ipc/interfaces.cpp
+++ b/src/ipc/interfaces.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
 #include <interfaces/init.h>
 #include <interfaces/ipc.h>
 #include <ipc/capnp/protocol.h>
@@ -10,6 +9,7 @@
 #include <ipc/protocol.h>
 #include <logging.h>
 #include <tinyformat.h>
+#include <util/fs.h>
 #include <util/system.h>
 
 #include <cstdio>
diff --git a/src/ipc/process.cpp b/src/ipc/process.cpp
index 9474ad2c4a07..c9e1fed26f19 100644
--- a/src/ipc/process.cpp
+++ b/src/ipc/process.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 <fs.h>
 #include <ipc/process.h>
 #include <ipc/protocol.h>
 #include <mp/util.h>
 #include <tinyformat.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 
 #include <cstdint>
diff --git a/src/ipc/process.h b/src/ipc/process.h
index 4bb2930d9c3d..40f2d2acf661 100644
--- a/src/ipc/process.h
+++ b/src/ipc/process.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_IPC_PROCESS_H
 #define BITCOIN_IPC_PROCESS_H
 
+#include <util/fs.h>
+
 #include <memory>
 #include <string>
 
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index ce7948e62132..59b7b57f3d31 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -45,7 +45,7 @@ static const std::string DB_MINED_COMMITMENT_BY_INVERSED_HEIGHT_Q_INDEXED = "q_m
 
 static const std::string DB_BEST_BLOCK_UPGRADE = "q_bbu2";
 
-CQuorumBlockProcessor::CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
+CQuorumBlockProcessor::CQuorumBlockProcessor(Chainstate& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
                                              CQuorumSnapshotManager& qsnapman, int8_t bls_threads) :
     m_chainstate{chainstate},
     m_dmnman{dmnman},
diff --git a/src/llmq/blockprocessor.h b/src/llmq/blockprocessor.h
index 15ca83307117..4cf2598b3f44 100644
--- a/src/llmq/blockprocessor.h
+++ b/src/llmq/blockprocessor.h
@@ -25,7 +25,7 @@ class CBlock;
 class CBlockIndex;
 class CBLSSignature;
 class CChain;
-class CChainState;
+class Chainstate;
 class CDataStream;
 class CDeterministicMNManager;
 class CEvoDB;
@@ -41,7 +41,7 @@ class CQuorumSnapshotManager;
 class CQuorumBlockProcessor
 {
 private:
-    CChainState& m_chainstate;
+    Chainstate& m_chainstate;
     CDeterministicMNManager& m_dmnman;
     CEvoDB& m_evoDb;
     CQuorumSnapshotManager& m_qsnapman;
@@ -58,7 +58,7 @@ class CQuorumBlockProcessor
     CQuorumBlockProcessor() = delete;
     CQuorumBlockProcessor(const CQuorumBlockProcessor&) = delete;
     CQuorumBlockProcessor& operator=(const CQuorumBlockProcessor&) = delete;
-    explicit CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
+    explicit CQuorumBlockProcessor(Chainstate& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
                                    CQuorumSnapshotManager& qsnapman, int8_t bls_threads);
     ~CQuorumBlockProcessor();
 
diff --git a/src/llmq/signing.h b/src/llmq/signing.h
index 0d9cc71bf7a4..f1a575bdf344 100644
--- a/src/llmq/signing.h
+++ b/src/llmq/signing.h
@@ -19,7 +19,7 @@
 #include <unordered_map>
 #include <variant>
 
-class CChainState;
+class Chainstate;
 class CDataStream;
 class CDBBatch;
 class CDBWrapper;
diff --git a/src/logging.cpp b/src/logging.cpp
index 98dcf1e2c69d..95d52fbe9e04 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -3,8 +3,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
 #include <logging.h>
+#include <util/fs.h>
 #include <util/string.h>
 #include <util/threadnames.h>
 #include <util/time.h>
diff --git a/src/logging.h b/src/logging.h
index d0b2069319f0..3016e3664255 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -6,9 +6,9 @@
 #ifndef BITCOIN_LOGGING_H
 #define BITCOIN_LOGGING_H
 
-#include <fs.h>
 #include <threadsafety.h>
 #include <tinyformat.h>
+#include <util/fs.h>
 #include <util/string.h>
 
 #include <atomic>
diff --git a/src/net.cpp b/src/net.cpp
index 21648dbd01c5..81d33d04baf1 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -19,7 +19,7 @@
 #include <consensus/consensus.h>
 #include <crypto/sha256.h>
 #include <node/eviction.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <i2p.h>
 #include <key.h>
 #include <memusage.h>
diff --git a/src/net.h b/src/net.h
index fbea1d395be8..51abda488275 100644
--- a/src/net.h
+++ b/src/net.h
@@ -12,7 +12,7 @@
 #include <compat/compat.h>
 #include <consensus/amount.h>
 #include <consensus/params.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <crypto/siphash.h>
 #include <hash.h>
 #include <i2p.h>
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index d6606442475a..e019b8a12a14 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -9,7 +9,7 @@
 #include <clientversion.h>
 #include <consensus/validation.h>
 #include <flatfile.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <hash.h>
 #include <pow.h>
 #include <shutdown.h>
@@ -897,7 +897,7 @@ void ThreadImport(ChainstateManager& chainman, std::vector<fs::path> vImportFile
         // We can't hold cs_main during ActivateBestChain even though we're accessing
         // the chainman unique_ptrs since ABC requires us not to be holding cs_main, so retrieve
         // the relevant pointers before the ABC call.
-        for (CChainState* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
+        for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
             BlockValidationState state;
             if (!chainstate->ActivateBestChain(state, nullptr)) {
                 LogPrintf("Failed to connect best block (%s)\n", state.ToString());
diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
index e524f27e6d2f..e0961b796ed2 100644
--- a/src/node/blockstorage.h
+++ b/src/node/blockstorage.h
@@ -8,7 +8,7 @@
 #include <attributes.h>
 #include <chain.h>
 #include <chainparams.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <kernel/blockmanager_opts.h>
 #include <protocol.h>
 #include <sync.h>
@@ -27,7 +27,7 @@ class CBlock;
 class CBlockUndo;
 class CChain;
 class CChainParams;
-class CChainState;
+class Chainstate;
 class ChainstateManager;
 struct CCheckpointData;
 struct FlatFilePos;
@@ -90,12 +90,12 @@ struct PruneLockInfo {
  * Maintains a tree of blocks (stored in `m_block_index`) which is consulted
  * to determine where the most-work tip is.
  *
- * This data is used mostly in `CChainState` - information about, e.g.,
+ * This data is used mostly in `Chainstate` - information about, e.g.,
  * candidate tips is not maintained here.
  */
 class BlockManager
 {
-    friend CChainState;
+    friend Chainstate;
     friend ChainstateManager;
 
 private:
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index 289720d0949f..aaed4ffc8719 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -64,7 +64,7 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      std::function<bool()> shutdown_requested,
                                                      std::function<void()> coins_error_cb)
 {
-    auto is_coinsview_empty = [&](CChainState* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
+    auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         return fReset || fReindexChainState || chainstate->CoinsTip().GetBestBlock().IsNull();
     };
 
@@ -152,7 +152,7 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
     // At this point we're either in reindex or we've loaded a useful
     // block tree into BlockIndex()!
 
-    for (CChainState* chainstate : chainman.GetAll()) {
+    for (Chainstate* chainstate : chainman.GetAll()) {
         chainstate->InitCoinsDB(
             /*cache_size_bytes=*/nCoinDBCache,
             /*in_memory=*/coins_db_in_memory,
@@ -262,13 +262,13 @@ std::optional<ChainstateLoadVerifyError> VerifyLoadedChainstate(ChainstateManage
                                                                 std::function<int64_t()> get_unix_time_seconds,
                                                                 std::function<void(bool)> notify_bls_state)
 {
-    auto is_coinsview_empty = [&](CChainState* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
+    auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         return fReset || fReindexChainState || chainstate->CoinsTip().GetBestBlock().IsNull();
     };
 
     LOCK(cs_main);
 
-    for (CChainState* chainstate : chainman.GetAll()) {
+    for (Chainstate* chainstate : chainman.GetAll()) {
         if (!is_coinsview_empty(chainstate)) {
             const CBlockIndex* tip = chainstate->m_chain.Tip();
             if (tip && tip->nTime > get_unix_time_seconds() + MAX_FUTURE_BLOCK_TIME) {
@@ -300,7 +300,7 @@ std::optional<ChainstateLoadVerifyError> VerifyLoadedChainstate(ChainstateManage
             }
 
         } else {
-            // TODO: CEvoDB instance should probably be a part of CChainState
+            // TODO: CEvoDB instance should probably be a part of Chainstate
             // (for multiple chainstates to actually work in parallel)
             // and not a global
             if (&chainman.ActiveChainstate() == chainstate && !evodb.IsEmpty()) {
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index f3eac13383ad..5cf464cfc831 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -1223,7 +1223,7 @@ class ChainImpl : public Chain
     std::optional<int> findLocatorFork(const CBlockLocator& locator) override
     {
         LOCK(::cs_main);
-        const CChainState& active = chainman().ActiveChainstate();
+        const Chainstate& active = chainman().ActiveChainstate();
         if (const CBlockIndex* fork = active.FindForkInGlobalIndex(locator)) {
             return fork->nHeight;
         }
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index d93c320eb195..64a074187579 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -69,7 +69,7 @@ BlockAssembler::Options::Options()
     nBlockMaxSize = DEFAULT_BLOCK_MAX_SIZE;
 }
 
-BlockAssembler::BlockAssembler(CChainState& chainstate, const NodeContext& node, const CTxMemPool* mempool, const CChainParams& params, const Options& options) :
+BlockAssembler::BlockAssembler(Chainstate& chainstate, const NodeContext& node, const CTxMemPool* mempool, const CChainParams& params, const Options& options) :
       m_blockman(chainstate.m_blockman),
       m_chain_helper(chainstate.ChainHelper()),
       m_chainstate(chainstate),
@@ -103,7 +103,7 @@ static BlockAssembler::Options DefaultOptions()
     return options;
 }
 
-BlockAssembler::BlockAssembler(CChainState& chainstate, const NodeContext& node, const CTxMemPool* mempool, const CChainParams& params)
+BlockAssembler::BlockAssembler(Chainstate& chainstate, const NodeContext& node, const CTxMemPool* mempool, const CChainParams& params)
     : BlockAssembler(chainstate, node, mempool, params, DefaultOptions()) {}
 
 void BlockAssembler::resetBlock()
diff --git a/src/node/miner.h b/src/node/miner.h
index f16bb8ef5d94..1c6c7cac2730 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -170,7 +170,7 @@ class BlockAssembler
 
     BlockManager& m_blockman;
     CChainstateHelper& m_chain_helper;
-    CChainState& m_chainstate;
+    Chainstate& m_chainstate;
     CEvoDB& m_evoDb;
     const chainlock::Chainlocks& m_chainlocks;
     chainlock::ChainlockHandler& m_clhandler;
@@ -187,8 +187,8 @@ class BlockAssembler
         CFeeRate blockMinFeeRate;
     };
 
-    explicit BlockAssembler(CChainState& chainstate, const node::NodeContext& node, const CTxMemPool* mempool, const CChainParams& params);
-    explicit BlockAssembler(CChainState& chainstate, const node::NodeContext& node, const CTxMemPool* mempool, const CChainParams& params,
+    explicit BlockAssembler(Chainstate& chainstate, const node::NodeContext& node, const CTxMemPool* mempool, const CChainParams& params);
+    explicit BlockAssembler(Chainstate& chainstate, const node::NodeContext& node, const CTxMemPool* mempool, const CChainParams& params,
                             const Options& options);
 
     /** Construct a new block template with coinbase to scriptPubKeyIn */
diff --git a/src/node/utxo_snapshot.h b/src/node/utxo_snapshot.h
index 401d4baaeb92..9dd6f0699734 100644
--- a/src/node/utxo_snapshot.h
+++ b/src/node/utxo_snapshot.h
@@ -11,7 +11,7 @@
 
 namespace node {
 //! Metadata describing a serialized version of a UTXO set from which an
-//! assumeutxo CChainState can be constructed.
+//! assumeutxo Chainstate can be constructed.
 class SnapshotMetadata
 {
 public:
diff --git a/src/policy/fees.cpp b/src/policy/fees.cpp
index 03b629e7b9e6..37a6c5a6eb04 100644
--- a/src/policy/fees.cpp
+++ b/src/policy/fees.cpp
@@ -7,7 +7,7 @@
 
 #include <clientversion.h>
 #include <consensus/amount.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <logging.h>
 #include <policy/feerate.h>
 #include <primitives/transaction.h>
diff --git a/src/policy/fees.h b/src/policy/fees.h
index 45bc40ab75c0..fd995302c7b5 100644
--- a/src/policy/fees.h
+++ b/src/policy/fees.h
@@ -11,6 +11,7 @@
 #include <sync.h>
 #include <threadsafety.h>
 #include <uint256.h>
+#include <util/fs.h>
 
 #include <array>
 #include <map>
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index 08132c0a3848..d2e48da4f7f8 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -10,7 +10,7 @@
 #include <qt/bitcoin.h>
 
 #include <chainparams.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <init.h>
 #include <interfaces/handler.h>
 #include <interfaces/init.h>
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index 2b02ac80e1a4..20014e417012 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -14,7 +14,8 @@
 
 #include <base58.h>
 #include <chainparams.h>
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <policy/policy.h>
diff --git a/src/qt/guiutil.h b/src/qt/guiutil.h
index 3a9b9240400a..5ccdd8987f9f 100644
--- a/src/qt/guiutil.h
+++ b/src/qt/guiutil.h
@@ -6,10 +6,10 @@
 #define BITCOIN_QT_GUIUTIL_H
 
 #include <consensus/amount.h>
-#include <fs.h>
 #include <net.h>
 #include <netaddress.h>
 #include <util/check.h>
+#include <util/fs.h>
 
 #include <qt/bitcoinunits.h>
 #include <qt/guiconstants.h>
diff --git a/src/qt/intro.cpp b/src/qt/intro.cpp
index a11b2d447c0e..7a2ef16521f0 100644
--- a/src/qt/intro.cpp
+++ b/src/qt/intro.cpp
@@ -8,15 +8,16 @@
 #endif
 
 #include <chainparams.h>
-#include <fs.h>
 #include <qt/intro.h>
 #include <qt/forms/ui_intro.h>
+#include <util/fs.h>
 
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 
 #include <interfaces/node.h>
+#include <util/fs_helpers.h>
 #include <util/system.h>
 #include <validation.h>
 
diff --git a/src/qt/psbtoperationsdialog.cpp b/src/qt/psbtoperationsdialog.cpp
index 2a98bfa9abb1..23dbaaad375d 100644
--- a/src/qt/psbtoperationsdialog.cpp
+++ b/src/qt/psbtoperationsdialog.cpp
@@ -5,7 +5,6 @@
 #include <qt/psbtoperationsdialog.h>
 
 #include <core_io.h>
-#include <fs.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <node/psbt.h>
@@ -14,6 +13,7 @@
 #include <qt/forms/ui_psbtoperationsdialog.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 
 #include <fstream>
diff --git a/src/qt/test/optiontests.cpp b/src/qt/test/optiontests.cpp
index 17ffeb220b69..3db9c4e6a6a0 100644
--- a/src/qt/test/optiontests.cpp
+++ b/src/qt/test/optiontests.cpp
@@ -46,6 +46,17 @@ void OptionTests::migrateSettings()
 
     settings.sync();
 
+    QVERIFY(settings.contains("nDatabaseCache"));
+    QVERIFY(settings.contains("nThreadsScriptVerif"));
+    QVERIFY(settings.contains("fUseUPnP"));
+    QVERIFY(settings.contains("fListen"));
+    QVERIFY(settings.contains("bPrune"));
+    QVERIFY(settings.contains("nPruneSize"));
+    QVERIFY(settings.contains("fUseProxy"));
+    QVERIFY(settings.contains("addrProxy"));
+    QVERIFY(settings.contains("fUseSeparateProxyTor"));
+    QVERIFY(settings.contains("addrSeparateProxyTor"));
+
     OptionsModel options{m_node};
     bilingual_str error;
     QVERIFY(options.Init(error));
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index 466c347c19fb..67c52db1c8af 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -10,6 +10,7 @@
 #include <interfaces/init.h>
 #include <interfaces/node.h>
 #include <qt/bitcoin.h>
+#include <qt/guiconstants.h>
 #include <qt/test/apptests.h>
 #include <qt/test/optiontests.h>
 #include <qt/test/rpcnestedtests.h>
@@ -25,6 +26,7 @@
 #include <QApplication>
 #include <QDebug>
 #include <QObject>
+#include <QSettings>
 #include <QTest>
 
 #include <functional>
@@ -81,38 +83,47 @@ int main(int argc, char* argv[])
         setenv("QT_QPA_PLATFORM", "minimal", 0 /* overwrite */);
     #endif
 
-    BitcoinApplication app;
-    app.setApplicationName("Dash-Qt-test");
-    app.createNode(*init);
+
+    QCoreApplication::setOrganizationName(QAPP_ORG_NAME);
+    QCoreApplication::setApplicationName(QAPP_APP_NAME_DEFAULT "-test");
 
     int num_test_failures{0};
 
-    AppTests app_tests(app);
-    num_test_failures += QTest::qExec(&app_tests);
+    {
+        BitcoinApplication app;
+        app.createNode(*init);
+
+        AppTests app_tests(app);
+        num_test_failures += QTest::qExec(&app_tests);
 
-    OptionTests options_tests(app.node());
-    num_test_failures += QTest::qExec(&options_tests);
+        OptionTests options_tests(app.node());
+        num_test_failures += QTest::qExec(&options_tests);
 
-    URITests test1;
-    num_test_failures += QTest::qExec(&test1);
+        URITests test1;
+        num_test_failures += QTest::qExec(&test1);
 
-    RPCNestedTests test3(app.node());
-    num_test_failures += QTest::qExec(&test3);
+        RPCNestedTests test3(app.node());
+        num_test_failures += QTest::qExec(&test3);
 
 #ifdef ENABLE_WALLET
-    WalletTests test5(app.node());
-    num_test_failures += QTest::qExec(&test5);
+        WalletTests test5(app.node());
+        num_test_failures += QTest::qExec(&test5);
 
-    AddressBookTests test6(app.node());
-    num_test_failures += QTest::qExec(&test6);
+        AddressBookTests test6(app.node());
+        num_test_failures += QTest::qExec(&test6);
 #endif
     TrafficGraphDataTests test7;
     num_test_failures += QTest::qExec(&test7);
 
-    if (num_test_failures) {
-        qWarning("\nFailed tests: %d\n", num_test_failures);
-    } else {
-        qDebug("\nAll tests passed.\n");
+        if (num_test_failures) {
+            qWarning("\nFailed tests: %d\n", num_test_failures);
+        } else {
+            qDebug("\nAll tests passed.\n");
+        }
     }
+
+    QSettings settings;
+    settings.clear();
+
     return num_test_failures;
 }
diff --git a/src/qt/walletframe.cpp b/src/qt/walletframe.cpp
index a47dc431e683..f319a6d881d9 100644
--- a/src/qt/walletframe.cpp
+++ b/src/qt/walletframe.cpp
@@ -4,7 +4,8 @@
 
 #include <qt/walletframe.h>
 
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <node/interface_ui.h>
 #include <psbt.h>
 #include <util/system.h>
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 1803294f7b3c..47b5e9b72f6a 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -17,7 +17,7 @@
 #include <deploymentinfo.h>
 #include <deploymentstatus.h>
 #include <evo/chainhelper.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
@@ -83,7 +83,7 @@ static GlobalMutex cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock GUARDED_BY(cs_blockchange);
 
-extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, const CTxMemPool& mempool, const CChainState& active_chainstate, const chainlock::Chainlocks& chainlocks, const llmq::CInstantSendManager& isman, UniValue& entry, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS);
+extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, const CTxMemPool& mempool, const Chainstate& active_chainstate, const chainlock::Chainlocks& chainlocks, const llmq::CInstantSendManager& isman, UniValue& entry, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS);
 
 /* Calculate the difficulty for a given block index.
  */
@@ -725,7 +725,7 @@ static RPCHelpMan getblockheaders()
 
     ChainstateManager& chainman = EnsureChainman(node);
 
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
     CChain& active_chain = active_chainstate.m_chain;
 
     const CBlockIndex* pblockindex;
@@ -1062,7 +1062,7 @@ static RPCHelpMan pruneblockchain()
 
     ChainstateManager& chainman = EnsureAnyChainman(request.context);
     LOCK(cs_main);
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
     CChain& active_chain = active_chainstate.m_chain;
 
     int heightParam = request.params[0].getInt<int>();
@@ -1198,7 +1198,7 @@ static RPCHelpMan gettxoutsetinfo()
 
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     ChainstateManager& chainman = EnsureChainman(node);
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
     active_chainstate.ForceFlushStateToDisk();
 
     CCoinsView* coins_view;
@@ -1331,7 +1331,7 @@ static RPCHelpMan gettxout()
     ChainstateManager& chainman = EnsureChainman(node);
     LOCK(cs_main);
 
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
 
     UniValue ret(UniValue::VOBJ);
 
@@ -1400,7 +1400,7 @@ static RPCHelpMan verifychain()
     ChainstateManager& chainman = EnsureChainman(node);
     LOCK(cs_main);
 
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
     return CVerifyDB().VerifyDB(
         active_chainstate, Params().GetConsensus(), active_chainstate.CoinsTip(), *CHECK_NONFATAL(node.evodb), check_level, check_depth);
 },
@@ -1545,7 +1545,7 @@ RPCHelpMan getblockchaininfo()
     ChainstateManager& chainman = EnsureChainman(node);
 
     LOCK(cs_main);
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
 
     const CBlockIndex& tip{*CHECK_NONFATAL(active_chainstate.m_chain.Tip())};
     const int height{tip.nHeight};
@@ -1815,7 +1815,7 @@ static RPCHelpMan invalidateblock()
         }
     }
 
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
     active_chainstate.InvalidateBlock(state, pblockindex);
 
     if (state.IsValid()) {
@@ -1848,7 +1848,7 @@ static RPCHelpMan reconsiderblock()
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
     ChainstateManager& chainman = EnsureAnyChainman(request.context);
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
 
     uint256 hash(ParseHashV(request.params[0], "blockhash"));
     const bool ignore_chainlocks{request.params[1].isNull() ? false : request.params[1].get_bool()};
@@ -2554,7 +2554,7 @@ static RPCHelpMan scantxoutset()
         {
             ChainstateManager& chainman = EnsureChainman(node);
             LOCK(cs_main);
-            CChainState& active_chainstate = chainman.ActiveChainstate();
+            Chainstate& active_chainstate = chainman.ActiveChainstate();
             active_chainstate.ForceFlushStateToDisk();
             pcursor = CHECK_NONFATAL(active_chainstate.CoinsDB().Cursor());
             tip = CHECK_NONFATAL(active_chainstate.m_chain.Tip());
@@ -2735,7 +2735,7 @@ static RPCHelpMan dumptxoutset()
 
 UniValue CreateUTXOSnapshot(
     NodeContext& node,
-    CChainState& chainstate,
+    Chainstate& chainstate,
     AutoFile& afile,
     const fs::path& path,
     const fs::path& temppath)
diff --git a/src/rpc/blockchain.h b/src/rpc/blockchain.h
index 7c2051bd1d2e..2b3c666629e2 100644
--- a/src/rpc/blockchain.h
+++ b/src/rpc/blockchain.h
@@ -7,7 +7,7 @@
 
 #include <consensus/amount.h>
 #include <core_io.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <kernel/coinstats.h>
 #include <streams.h>
 #include <sync.h>
@@ -21,7 +21,7 @@ extern RecursiveMutex cs_main; // NOLINT(readability-redundant-declaration)
 
 class CBlock;
 class CBlockIndex;
-class CChainState;
+class Chainstate;
 class CCoinsView;
 namespace chainlock { class Chainlocks; }
 namespace kernel {
@@ -65,7 +65,7 @@ void CalculatePercentilesBySize(CAmount result[NUM_GETBLOCKSTATS_PERCENTILES], s
  */
 UniValue CreateUTXOSnapshot(
     node::NodeContext& node,
-    CChainState& chainstate,
+    Chainstate& chainstate,
     AutoFile& afile,
     const fs::path& path,
     const fs::path& tmppath);
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 8315c6a96db3..0881838c6b90 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -11,7 +11,7 @@
 
 #include <chainparams.h>
 #include <core_io.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <policy/settings.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
@@ -173,7 +173,7 @@ static RPCHelpMan testmempoolaccept()
             NodeContext& node = EnsureAnyNodeContext(request.context);
             CTxMemPool& mempool = EnsureMemPool(node);
             ChainstateManager& chainman = EnsureChainman(node);
-            CChainState& chainstate = chainman.ActiveChainstate();
+            Chainstate& chainstate = chainman.ActiveChainstate();
             const PackageMempoolAcceptResult package_result = [&] {
                 LOCK(::cs_main);
                 if (txns.size() > 1) return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/true);
@@ -831,7 +831,7 @@ static RPCHelpMan submitpackage()
 
             NodeContext& node = EnsureAnyNodeContext(request.context);
             CTxMemPool& mempool = EnsureMemPool(node);
-            CChainState& chainstate = EnsureChainman(node).ActiveChainstate();
+            Chainstate& chainstate = EnsureChainman(node).ActiveChainstate();
             const auto package_result = WITH_LOCK(::cs_main, return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/ false));
 
             // First catch any errors.
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 385240ee1e93..ecb80e2497ec 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -356,7 +356,7 @@ static RPCHelpMan generateblock()
     const CChainParams& chainparams(Params());
 
     ChainstateManager& chainman = EnsureChainman(node);
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
 
     CBlock block;
     {
@@ -659,7 +659,7 @@ static RPCHelpMan getblocktemplate()
     std::string strMode = "template";
     UniValue lpval = NullUniValue;
     std::set<std::string> setClientRules;
-    CChainState& active_chainstate = chainman.ActiveChainstate();
+    Chainstate& active_chainstate = chainman.ActiveChainstate();
     CChain& active_chain = active_chainstate.m_chain;
     if (!request.params[0].isNull())
     {
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 7a0dd1f71e05..7f9a01c7f539 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -70,7 +70,7 @@ using node::GetTransaction;
 using node::NodeContext;
 using node::PSBTAnalysis;
 
-void TxToJSON(const CTransaction& tx, const uint256 hashBlock, const  CTxMemPool& mempool, const CChainState& active_chainstate, const chainlock::Chainlocks& chainlocks, const llmq::CInstantSendManager& isman, UniValue& entry, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS)
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, const  CTxMemPool& mempool, const Chainstate& active_chainstate, const chainlock::Chainlocks& chainlocks, const llmq::CInstantSendManager& isman, UniValue& entry, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS)
 {
     CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS);
     LOCK(::cs_main);
@@ -618,7 +618,7 @@ static RPCHelpMan gettxchainlocks()
 {
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     const ChainstateManager& chainman = EnsureChainman(node);
-    const CChainState& active_chainstate = chainman.ActiveChainstate();
+    const Chainstate& active_chainstate = chainman.ActiveChainstate();
     CHECK_NONFATAL(node.chainlocks);
 
     UniValue result_arr(UniValue::VARR);
diff --git a/src/rpc/request.cpp b/src/rpc/request.cpp
index c30e16194d92..dc3f584c9ff6 100644
--- a/src/rpc/request.cpp
+++ b/src/rpc/request.cpp
@@ -6,7 +6,8 @@
 
 #include <rpc/request.h>
 
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <random.h>
 #include <rpc/protocol.h>
 #include <util/system.h>
diff --git a/src/rpc/txoutproof.cpp b/src/rpc/txoutproof.cpp
index bf7b8dc2e069..79c685721bf0 100644
--- a/src/rpc/txoutproof.cpp
+++ b/src/rpc/txoutproof.cpp
@@ -70,7 +70,7 @@ static RPCHelpMan gettxoutproof()
                 }
             } else {
                 LOCK(cs_main);
-                CChainState& active_chainstate = chainman.ActiveChainstate();
+                Chainstate& active_chainstate = chainman.ActiveChainstate();
 
                 // Loop through txids and try to find which block they're in. Exit loop once a block is found.
                 for (const auto& tx : setTxids) {
diff --git a/src/stacktraces.cpp b/src/stacktraces.cpp
index f1d68f27dbc2..59410f438ad6 100644
--- a/src/stacktraces.cpp
+++ b/src/stacktraces.cpp
@@ -7,7 +7,7 @@
 #endif // HAVE_CONFIG_H
 
 #include <stacktraces.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <logging.h>
 #include <streams.h>
 #include <threadsafety.h>
diff --git a/src/test/argsman_tests.cpp b/src/test/argsman_tests.cpp
index eaa62f3cc13e..af3e560f5f47 100644
--- a/src/test/argsman_tests.cpp
+++ b/src/test/argsman_tests.cpp
@@ -2,14 +2,14 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/system.h>
-#include <fs.h>
 #include <sync.h>
 #include <test/util/logging.h>
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
-#include <util/strencodings.h>
 #include <univalue.h>
+#include <util/fs.h>
+#include <util/strencodings.h>
+#include <util/system.h>
 
 #include <array>
 #include <optional>
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
index b8f5a2b4b9f0..b1a334a5d4f3 100644
--- a/src/test/coinstatsindex_tests.cpp
+++ b/src/test/coinstatsindex_tests.cpp
@@ -78,7 +78,7 @@ BOOST_FIXTURE_TEST_CASE(coinstatsindex_initial_sync, TestChain100Setup)
 // make sure index is not corrupted and is able to reload.
 BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
 {
-    CChainState& chainstate = Assert(m_node.chainman)->ActiveChainstate();
+    Chainstate& chainstate = Assert(m_node.chainman)->ActiveChainstate();
     const CChainParams& params = Params();
     {
         CoinStatsIndex index{1 << 20};
diff --git a/src/test/fs_tests.cpp b/src/test/fs_tests.cpp
index 5110bd967a66..ee28c0a8b824 100644
--- a/src/test/fs_tests.cpp
+++ b/src/test/fs_tests.cpp
@@ -2,7 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <test/util/setup_common.h>
 #include <util/getuniquepath.h>
 #include <util/system.h>
diff --git a/src/test/fuzz/banman.cpp b/src/test/fuzz/banman.cpp
index 5e3cf8720204..de26e39b34d1 100644
--- a/src/test/fuzz/banman.cpp
+++ b/src/test/fuzz/banman.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <banman.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <netaddress.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
diff --git a/src/test/fuzz/fuzz.cpp b/src/test/fuzz/fuzz.cpp
index 817a69b16b36..3979285640b0 100644
--- a/src/test/fuzz/fuzz.cpp
+++ b/src/test/fuzz/fuzz.cpp
@@ -4,11 +4,11 @@
 
 #include <test/fuzz/fuzz.h>
 
-#include <fs.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <test/util/setup_common.h>
 #include <util/check.h>
+#include <util/fs.h>
 #include <util/sock.h>
 #include <util/time.h>
 
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 8799b1bad806..3a1486f42c64 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -32,7 +32,7 @@ struct MockedTxPool : public CTxMemPool {
     }
 };
 
-class DummyChainState final : public CChainState
+class DummyChainState final : public Chainstate
 {
 public:
     void SetMempool(CTxMemPool* mempool)
@@ -91,7 +91,7 @@ void SetMempoolConstraints(ArgsManager& args, FuzzedDataProvider& fuzzed_data_pr
                      ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 999)));
 }
 
-void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, const NodeContext& node, CChainState& chainstate)
+void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, const NodeContext& node, Chainstate& chainstate)
 {
     WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
     {
@@ -115,7 +115,7 @@ void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, con
     SyncWithValidationInterfaceQueue();
 }
 
-void MockTime(FuzzedDataProvider& fuzzed_data_provider, const CChainState& chainstate)
+void MockTime(FuzzedDataProvider& fuzzed_data_provider, const Chainstate& chainstate)
 {
     const auto time = ConsumeTime(fuzzed_data_provider,
                                   chainstate.m_chain.Tip()->GetMedianTimePast() + 1,
diff --git a/src/test/fuzz/utxo_snapshot.cpp b/src/test/fuzz/utxo_snapshot.cpp
index b4a5de6371b1..4e832f0ac885 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/fs.h>
 #include <validation.h>
 #include <validationinterface.h>
 
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 3c77fed9bd8f..8ea01278bf7f 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -850,7 +850,7 @@ BOOST_AUTO_TEST_CASE(initial_advertise_from_version_message)
     const int64_t time{0};
     const CNetMsgMaker msg_maker{PROTOCOL_VERSION};
 
-    // Force CChainState::IsInitialBlockDownload() to return false.
+    // Force Chainstate::IsInitialBlockDownload() to return false.
     // Otherwise PushAddress() isn't called by PeerManager::ProcessMessage().
     TestChainState& chainstate =
         *static_cast<TestChainState*>(&m_node.chainman->ActiveChainstate());
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index e4f21b73c2f0..c027dbe8720c 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -15,6 +15,7 @@
 #include <test/util/json.h>
 #include <test/util/setup_common.h>
 #include <test/util/transaction_utils.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 
 #if defined(HAVE_CONSENSUS_LIB)
diff --git a/src/test/settings_tests.cpp b/src/test/settings_tests.cpp
index ad12c4656106..4d0d42ae3848 100644
--- a/src/test/settings_tests.cpp
+++ b/src/test/settings_tests.cpp
@@ -4,9 +4,9 @@
 
 #include <util/settings.h>
 
-#include <fs.h>
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
+#include <util/fs.h>
 
 
 #include <boost/test/unit_test.hpp>
diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
index 6ee196239794..5e3dca7c7cfe 100644
--- a/src/test/streams_tests.cpp
+++ b/src/test/streams_tests.cpp
@@ -2,9 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
+#include <util/fs.h>
 
 #include <boost/test/unit_test.hpp>
 
diff --git a/src/test/util/chainstate.h b/src/test/util/chainstate.h
index 2f0021b11448..29a37d0a2364 100644
--- a/src/test/util/chainstate.h
+++ b/src/test/util/chainstate.h
@@ -6,7 +6,7 @@
 #define BITCOIN_TEST_UTIL_CHAINSTATE_H
 
 #include <clientversion.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <logging.h>
 #include <node/context.h>
 #include <node/utxo_snapshot.h>
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 8a96cb0c9ba4..dede915123ed 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -504,7 +504,7 @@ void TestChainSetup::mineBlocks(int num_blocks)
 CBlock TestChainSetup::CreateAndProcessBlock(
     const std::vector<CMutableTransaction>& txns,
     const CScript& scriptPubKey,
-    CChainState* chainstate)
+    Chainstate* chainstate)
 {
     if (!chainstate) {
         chainstate = &Assert(m_node.chainman)->ActiveChainstate();
@@ -520,7 +520,7 @@ CBlock TestChainSetup::CreateAndProcessBlock(
 CBlock TestChainSetup::CreateBlock(
     const std::vector<CMutableTransaction>& txns,
     const CScript& scriptPubKey,
-    CChainState& chainstate)
+    Chainstate& chainstate)
 {
     const CChainParams& chainparams = Params();
     CTxMemPool empty_pool;
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index deba315dac4b..0d75c8d0c81b 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -7,7 +7,6 @@
 #define BITCOIN_TEST_UTIL_SETUP_COMMON_H
 
 #include <chainparamsbase.h>
-#include <fs.h>
 #include <key.h>
 #include <node/caches.h>
 #include <node/context.h> // IWYU pragma: export
@@ -15,6 +14,7 @@
 #include <pubkey.h>
 #include <random.h>
 #include <util/check.h>
+#include <util/fs.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/time.h>
@@ -31,7 +31,7 @@ namespace Consensus {
 struct Params;
 };
 
-class CChainState;
+class Chainstate;
 
 /** This is connected to the logger. Can be used to redirect logs to any other log */
 extern const std::function<void(const std::string&)> G_TEST_LOG_FUN;
@@ -163,7 +163,7 @@ struct TestChainSetup : public TestingSetup
      */
     CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns,
                                  const CScript& scriptPubKey,
-                                 CChainState* chainstate = nullptr);
+                                 Chainstate* chainstate = nullptr);
 
     /**
      * Create a new block with just given transactions, coinbase paying to
@@ -171,7 +171,7 @@ struct TestChainSetup : public TestingSetup
      */
     CBlock CreateBlock(const std::vector<CMutableTransaction>& txns,
                        const CScript& scriptPubKey,
-                       CChainState& chainstate);
+                       Chainstate& chainstate);
 
     //! Mine a series of new blocks on the active chain.
     void mineBlocks(int num_blocks);
diff --git a/src/test/util/validation.h b/src/test/util/validation.h
index b0bc717b6c22..cbe7745b81e4 100644
--- a/src/test/util/validation.h
+++ b/src/test/util/validation.h
@@ -9,7 +9,7 @@
 
 class CValidationInterface;
 
-struct TestChainState : public CChainState {
+struct TestChainState : public Chainstate {
     /** Reset the ibd cache to its initial state */
     void ResetIbd();
     /** Toggle IsInitialBlockDownload from true to false */
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 2da64caf6576..dedfb9c80bbe 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -2,15 +2,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/system.h>
-
 #include <clientversion.h>
-#include <fs.h>
 #include <hash.h> // For Hash()
 #include <key.h>  // For CKey
 #include <sync.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
+#include <util/bitdeque.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <util/getuniquepath.h>
 #include <util/message.h> // For MessageSign(), MessageVerify(), MESSAGE_MAGIC
 #include <util/moneystr.h>
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index d1a3fda4539f..78d4f21d4c48 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -20,7 +20,7 @@
 
 BOOST_FIXTURE_TEST_SUITE(validation_chainstate_tests, ChainTestingSetup)
 
-//! Test resizing coins-related CChainState caches during runtime.
+//! Test resizing coins-related Chainstate caches during runtime.
 //!
 BOOST_AUTO_TEST_CASE(validation_chainstate_resize_caches)
 {
@@ -40,7 +40,7 @@ BOOST_AUTO_TEST_CASE(validation_chainstate_resize_caches)
         return outp;
     };
 
-    CChainState& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.evodb, m_node.chain_helper));
+    Chainstate& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.evodb, m_node.chain_helper));
     c1.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
     WITH_LOCK(::cs_main, c1.InitCoinsCache(1 << 23));
@@ -108,8 +108,8 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
 
     BOOST_CHECK_EQUAL(chainman.GetAll().size(), 2);
 
-    CChainState& background_cs{*[&] {
-        for (CChainState* cs : chainman.GetAll()) {
+    Chainstate& background_cs{*[&] {
+        for (Chainstate* cs : chainman.GetAll()) {
             if (cs != &chainman.ActiveChainstate()) {
                 return cs;
             }
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
index af77dc04dff3..bbf8cf6070f6 100644
--- a/src/test/validation_chainstatemanager_tests.cpp
+++ b/src/test/validation_chainstatemanager_tests.cpp
@@ -40,13 +40,13 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
     ChainstateManager& manager = *m_node.chainman;
     CTxMemPool& mempool = *m_node.mempool;
     CEvoDB& evodb = *m_node.evodb;
-    std::vector<CChainState*> chainstates;
+    std::vector<Chainstate*> chainstates;
 
     BOOST_CHECK(!manager.SnapshotBlockhash().has_value());
 
     // Create a legacy (IBD) chainstate.
     //
-    CChainState& c1 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper));
+    Chainstate& c1 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper));
     chainstates.push_back(&c1);
     c1.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
@@ -78,7 +78,7 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
     // Create a snapshot-based chainstate.
     //
     const uint256 snapshot_blockhash = GetRandHash();
-    CChainState& c2 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(
+    Chainstate& c2 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(
         &mempool, evodb, m_node.chain_helper,
         snapshot_blockhash)
     );
@@ -135,11 +135,11 @@ BOOST_AUTO_TEST_CASE(chainstatemanager_rebalance_caches)
     manager.m_total_coinsdb_cache = max_cache;
     manager.m_total_coinstip_cache = max_cache;
 
-    std::vector<CChainState*> chainstates;
+    std::vector<Chainstate*> chainstates;
 
     // Create a legacy (IBD) chainstate.
     //
-    CChainState& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper));
+    Chainstate& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper));
     chainstates.push_back(&c1);
     c1.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
@@ -157,7 +157,7 @@ BOOST_AUTO_TEST_CASE(chainstatemanager_rebalance_caches)
 
     // Create a snapshot-based chainstate.
     //
-    CChainState& c2 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper, GetRandHash()));
+    Chainstate& c2 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper, GetRandHash()));
     chainstates.push_back(&c2);
     c2.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
@@ -274,7 +274,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_activate_snapshot, TestChain100Setup)
         LOCK(::cs_main);
         int chains_tested{0};
 
-        for (CChainState* chainstate : chainman.GetAll()) {
+        for (Chainstate* chainstate : chainman.GetAll()) {
             BOOST_TEST_MESSAGE("Checking coins in " << chainstate->ToString());
             CCoinsViewCache& coinscache = chainstate->CoinsTip();
 
@@ -307,7 +307,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_activate_snapshot, TestChain100Setup)
         size_t coins_in_background{0};
         size_t coins_missing_from_background{0};
 
-        for (CChainState* chainstate : chainman.GetAll()) {
+        for (Chainstate* chainstate : chainman.GetAll()) {
             BOOST_TEST_MESSAGE("Checking coins in " << chainstate->ToString());
             CCoinsViewCache& coinscache = chainstate->CoinsTip();
             bool is_background = chainstate != &chainman.ActiveChainstate();
@@ -350,7 +350,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_loadblockindex, TestChain100Setup)
 {
     ChainstateManager& chainman = *Assert(m_node.chainman);
     CTxMemPool& mempool = *m_node.mempool;
-    CChainState& cs1 = chainman.ActiveChainstate();
+    Chainstate& cs1 = chainman.ActiveChainstate();
 
     int num_indexes{0};
     int num_assumed_valid{0};
@@ -362,7 +362,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_loadblockindex, TestChain100Setup)
     CBlockIndex* assumed_tip{chainman.ActiveChain().Tip()};
 
     auto reload_all_block_indexes = [&]() {
-        for (CChainState* cs : chainman.GetAll()) {
+        for (Chainstate* cs : chainman.GetAll()) {
             LOCK(::cs_main);
             cs->UnloadBlockIndex();
             BOOST_CHECK(cs->setBlockIndexCandidates.empty());
@@ -397,7 +397,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_loadblockindex, TestChain100Setup)
 
     BOOST_CHECK_EQUAL(expected_assumed_valid, num_assumed_valid);
 
-    CChainState& cs2 = WITH_LOCK(::cs_main,
+    Chainstate& cs2 = WITH_LOCK(::cs_main,
         return chainman.InitializeChainstate(&mempool, *m_node.evodb, m_node.chain_helper, GetRandHash()));
 
     reload_all_block_indexes();
diff --git a/src/test/validation_flush_tests.cpp b/src/test/validation_flush_tests.cpp
index 960dd2997baf..99eb3f47ff32 100644
--- a/src/test/validation_flush_tests.cpp
+++ b/src/test/validation_flush_tests.cpp
@@ -14,11 +14,11 @@ BOOST_FIXTURE_TEST_SUITE(validation_flush_tests, TestingSetup)
 //! Test utilities for detecting when we need to flush the coins cache based
 //! on estimated memory usage.
 //!
-//! @sa CChainState::GetCoinsCacheSizeState()
+//! @sa Chainstate::GetCoinsCacheSizeState()
 //!
 BOOST_AUTO_TEST_CASE(getcoinscachesizestate)
 {
-    CChainState& chainstate{m_node.chainman->ActiveChainstate()};
+    Chainstate& chainstate{m_node.chainman->ActiveChainstate()};
 
     constexpr bool is_64_bit = sizeof(void*) == 8;
 
diff --git a/src/torcontrol.h b/src/torcontrol.h
index 3b4fcb0b7ee3..4a0eef223e41 100644
--- a/src/torcontrol.h
+++ b/src/torcontrol.h
@@ -8,8 +8,8 @@
 #ifndef BITCOIN_TORCONTROL_H
 #define BITCOIN_TORCONTROL_H
 
-#include <fs.h>
 #include <netaddress.h>
+#include <util/fs.h>
 
 #include <event2/util.h>
 
diff --git a/src/txmempool.h b/src/txmempool.h
index d2285f1bbdf3..6f1289ad69fe 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -41,7 +41,7 @@
 
 class CBlockIndex;
 class CChain;
-class CChainState;
+class Chainstate;
 extern RecursiveMutex cs_main; // NOLINT(readability-redundant-declaration)
 
 // Forward declaration for CBLSLazyPublicKey:
diff --git a/src/util/asmap.cpp b/src/util/asmap.cpp
index 47f25c7aef4a..bca8358c2d42 100644
--- a/src/util/asmap.cpp
+++ b/src/util/asmap.cpp
@@ -5,7 +5,7 @@
 #include <util/asmap.h>
 
 #include <clientversion.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <logging.h>
 #include <serialize.h>
 #include <streams.h>
diff --git a/src/util/asmap.h b/src/util/asmap.h
index 844037f81617..08a88f1b3c5a 100644
--- a/src/util/asmap.h
+++ b/src/util/asmap.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_UTIL_ASMAP_H
 #define BITCOIN_UTIL_ASMAP_H
 
-#include <fs.h>
+#include <util/fs.h>
 
 #include <cstdint>
 #include <vector>
diff --git a/src/fs.cpp b/src/util/fs.cpp
similarity index 99%
rename from src/fs.cpp
rename to src/util/fs.cpp
index bf90bda00688..f22325e97d42 100644
--- a/src/fs.cpp
+++ b/src/util/fs.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
+#include <util/fs.h>
 #include <util/syserror.h>
 
 #ifndef WIN32
diff --git a/src/fs.h b/src/util/fs.h
similarity index 99%
rename from src/fs.h
rename to src/util/fs.h
index 270ce6fd1f00..64fcdd24ebd0 100644
--- a/src/fs.h
+++ b/src/util/fs.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_FS_H
-#define BITCOIN_FS_H
+#ifndef BITCOIN_UTIL_FS_H
+#define BITCOIN_UTIL_FS_H
 
 #include <tinyformat.h>
 
@@ -247,4 +247,4 @@ template<> inline void formatValue(std::ostream&, const char*, const char*, int,
 template<> inline void formatValue(std::ostream&, const char*, const char*, int, const fs::path&) = delete;
 } // namespace tinyformat
 
-#endif // BITCOIN_FS_H
+#endif // BITCOIN_UTIL_FS_H
diff --git a/src/util/fs_helpers.cpp b/src/util/fs_helpers.cpp
new file mode 100644
index 000000000000..4a7c9682d3dd
--- /dev/null
+++ b/src/util/fs_helpers.cpp
@@ -0,0 +1,296 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-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/fs_helpers.h>
+
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+
+#include <logging.h>
+#include <sync.h>
+#include <tinyformat.h>
+#include <util/fs.h>
+#include <util/getuniquepath.h>
+#include <util/system.h>
+
+#include <cerrno>
+#include <filesystem>
+#include <fstream>
+#include <map>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
+
+#ifndef WIN32
+// for posix_fallocate, in configure.ac we check if it is present after this
+#ifdef __linux__
+
+#ifdef _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#endif
+
+#define _POSIX_C_SOURCE 200112L
+
+#endif // __linux__
+
+#include <fcntl.h>
+#include <sys/resource.h>
+#include <unistd.h>
+#else
+#include <io.h> /* For _get_osfhandle, _chsize */
+#include <shlobj.h> /* For SHGetSpecialFolderPathW */
+#endif // WIN32
+
+/** Mutex to protect dir_locks. */
+static GlobalMutex cs_dir_locks;
+/** A map that contains all the currently held directory locks. After
+ * successful locking, these will be held here until the global destructor
+ * cleans them up and thus automatically unlocks them, or ReleaseDirectoryLocks
+ * is called.
+ */
+static std::map<std::string, std::unique_ptr<fsbridge::FileLock>> dir_locks GUARDED_BY(cs_dir_locks);
+
+bool LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only)
+{
+    LOCK(cs_dir_locks);
+    fs::path pathLockFile = directory / lockfile_name;
+
+    // If a lock for this directory already exists in the map, don't try to re-lock it
+    if (dir_locks.count(fs::PathToString(pathLockFile))) {
+        return true;
+    }
+
+    // Create empty lock file if it doesn't exist.
+    FILE* file = fsbridge::fopen(pathLockFile, "a");
+    if (file) fclose(file);
+    auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
+    if (!lock->TryLock()) {
+        return error("Error while attempting to lock directory %s: %s", fs::PathToString(directory), lock->GetReason());
+    }
+    if (!probe_only) {
+        // Lock successful and we're not just probing, put it into the map
+        dir_locks.emplace(fs::PathToString(pathLockFile), std::move(lock));
+    }
+    return true;
+}
+
+void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name)
+{
+    LOCK(cs_dir_locks);
+    dir_locks.erase(fs::PathToString(directory / lockfile_name));
+}
+
+void ReleaseDirectoryLocks()
+{
+    LOCK(cs_dir_locks);
+    dir_locks.clear();
+}
+
+bool DirIsWritable(const fs::path& directory)
+{
+    fs::path tmpFile = GetUniquePath(directory);
+
+    FILE* file = fsbridge::fopen(tmpFile, "a");
+    if (!file) return false;
+
+    fclose(file);
+    remove(tmpFile);
+
+    return true;
+}
+
+bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes)
+{
+    constexpr uint64_t min_disk_space = 52428800; // 50 MiB
+
+    uint64_t free_bytes_available = fs::space(dir).available;
+    return free_bytes_available >= min_disk_space + additional_bytes;
+}
+
+std::streampos GetFileSize(const char* path, std::streamsize max)
+{
+    std::ifstream file{path, std::ios::binary};
+    file.ignore(max);
+    return file.gcount();
+}
+
+bool FileCommit(FILE* file)
+{
+    if (fflush(file) != 0) { // harmless if redundantly called
+        LogPrintf("%s: fflush failed: %d\n", __func__, errno);
+        return false;
+    }
+#ifdef WIN32
+    HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
+    if (FlushFileBuffers(hFile) == 0) {
+        LogPrintf("%s: FlushFileBuffers failed: %d\n", __func__, GetLastError());
+        return false;
+    }
+#elif defined(MAC_OSX) && defined(F_FULLFSYNC)
+    if (fcntl(fileno(file), F_FULLFSYNC, 0) == -1) { // Manpage says "value other than -1" is returned on success
+        LogPrintf("%s: fcntl F_FULLFSYNC failed: %d\n", __func__, errno);
+        return false;
+    }
+#elif HAVE_FDATASYNC
+    if (fdatasync(fileno(file)) != 0 && errno != EINVAL) { // Ignore EINVAL for filesystems that don't support sync
+        LogPrintf("%s: fdatasync failed: %d\n", __func__, errno);
+        return false;
+    }
+#else
+    if (fsync(fileno(file)) != 0 && errno != EINVAL) {
+        LogPrintf("%s: fsync failed: %d\n", __func__, errno);
+        return false;
+    }
+#endif
+    return true;
+}
+
+void DirectoryCommit(const fs::path& dirname)
+{
+#ifndef WIN32
+    FILE* file = fsbridge::fopen(dirname, "r");
+    if (file) {
+        fsync(fileno(file));
+        fclose(file);
+    }
+#endif
+}
+
+bool TruncateFile(FILE* file, unsigned int length)
+{
+#if defined(WIN32)
+    return _chsize(_fileno(file), length) == 0;
+#else
+    return ftruncate(fileno(file), length) == 0;
+#endif
+}
+
+/**
+ * this function tries to raise the file descriptor limit to the requested number.
+ * It returns the actual file descriptor limit (which may be more or less than nMinFD)
+ */
+int RaiseFileDescriptorLimit(int nMinFD)
+{
+#if defined(WIN32)
+    return 2048;
+#else
+    struct rlimit limitFD;
+    if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
+        if (limitFD.rlim_cur < (rlim_t)nMinFD) {
+            limitFD.rlim_cur = nMinFD;
+            if (limitFD.rlim_cur > limitFD.rlim_max)
+                limitFD.rlim_cur = limitFD.rlim_max;
+            setrlimit(RLIMIT_NOFILE, &limitFD);
+            getrlimit(RLIMIT_NOFILE, &limitFD);
+        }
+        return limitFD.rlim_cur;
+    }
+    return nMinFD; // getrlimit failed, assume it's fine
+#endif
+}
+
+/**
+ * this function tries to make a particular range of a file allocated (corresponding to disk space)
+ * it is advisory, and the range specified in the arguments will never contain live data
+ */
+void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length)
+{
+#if defined(WIN32)
+    // Windows-specific version
+    HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
+    LARGE_INTEGER nFileSize;
+    int64_t nEndPos = (int64_t)offset + length;
+    nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
+    nFileSize.u.HighPart = nEndPos >> 32;
+    SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
+    SetEndOfFile(hFile);
+#elif defined(MAC_OSX)
+    // OSX specific version
+    // NOTE: Contrary to other OS versions, the OSX version assumes that
+    // NOTE: offset is the size of the file.
+    fstore_t fst;
+    fst.fst_flags = F_ALLOCATECONTIG;
+    fst.fst_posmode = F_PEOFPOSMODE;
+    fst.fst_offset = 0;
+    fst.fst_length = length; // mac os fst_length takes the # of free bytes to allocate, not desired file size
+    fst.fst_bytesalloc = 0;
+    if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
+        fst.fst_flags = F_ALLOCATEALL;
+        fcntl(fileno(file), F_PREALLOCATE, &fst);
+    }
+    ftruncate(fileno(file), static_cast<off_t>(offset) + length);
+#else
+#if defined(HAVE_POSIX_FALLOCATE)
+    // Version using posix_fallocate
+    off_t nEndPos = (off_t)offset + length;
+    if (0 == posix_fallocate(fileno(file), 0, nEndPos)) return;
+#endif
+    // Fallback version
+    // TODO: just write one byte per block
+    static const char buf[65536] = {};
+    if (fseek(file, offset, SEEK_SET)) {
+        return;
+    }
+    while (length > 0) {
+        unsigned int now = 65536;
+        if (length < now)
+            now = length;
+        fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
+        length -= now;
+    }
+#endif
+}
+
+#ifdef WIN32
+fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
+{
+    WCHAR pszPath[MAX_PATH] = L"";
+
+    if (SHGetSpecialFolderPathW(nullptr, pszPath, nFolder, fCreate)) {
+        return fs::path(pszPath);
+    }
+
+    LogPrintf("SHGetSpecialFolderPathW() failed, could not obtain requested path.\n");
+    return fs::path("");
+}
+#endif
+
+bool RenameOver(fs::path src, fs::path dest)
+{
+#ifdef __MINGW64__
+    // This is a workaround for a bug in libstdc++ which
+    // implements std::filesystem::rename with _wrename function.
+    // This bug has been fixed in upstream:
+    //  - GCC 10.3: 8dd1c1085587c9f8a21bb5e588dfe1e8cdbba79e
+    //  - GCC 11.1: 1dfd95f0a0ca1d9e6cbc00e6cbfd1fa20a98f312
+    // For more details see the commits mentioned above.
+    return MoveFileExW(src.wstring().c_str(), dest.wstring().c_str(),
+                       MOVEFILE_REPLACE_EXISTING) != 0;
+#else
+    std::error_code error;
+    fs::rename(src, dest, error);
+    return !error;
+#endif
+}
+
+/**
+ * Ignores exceptions thrown by create_directories if the requested directory exists.
+ * Specifically handles case where path p exists, but it wasn't possible for the user to
+ * write to the parent directory.
+ */
+bool TryCreateDirectories(const fs::path& p)
+{
+    try {
+        return fs::create_directories(p);
+    } catch (const fs::filesystem_error&) {
+        if (!fs::exists(p) || !fs::is_directory(p))
+            throw;
+    }
+
+    // create_directories didn't create the directory, it had to have existed already
+    return false;
+}
diff --git a/src/util/fs_helpers.h b/src/util/fs_helpers.h
new file mode 100644
index 000000000000..e7db01a89b9c
--- /dev/null
+++ b/src/util/fs_helpers.h
@@ -0,0 +1,63 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-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_FS_HELPERS_H
+#define BITCOIN_UTIL_FS_HELPERS_H
+
+#include <util/fs.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <iosfwd>
+#include <limits>
+
+/**
+ * Ensure file contents are fully committed to disk, using a platform-specific
+ * feature analogous to fsync().
+ */
+bool FileCommit(FILE* file);
+
+/**
+ * Sync directory contents. This is required on some environments to ensure that
+ * newly created files are committed to disk.
+ */
+void DirectoryCommit(const fs::path& dirname);
+
+bool TruncateFile(FILE* file, unsigned int length);
+int RaiseFileDescriptorLimit(int nMinFD);
+void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length);
+
+/**
+ * Rename src to dest.
+ * @return true if the rename was successful.
+ */
+[[nodiscard]] bool RenameOver(fs::path src, fs::path dest);
+
+bool LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only = false);
+void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name);
+bool DirIsWritable(const fs::path& directory);
+bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes = 0);
+
+/** Get the size of a file by scanning it.
+ *
+ * @param[in] path The file path
+ * @param[in] max Stop seeking beyond this limit
+ * @return The file size or max
+ */
+std::streampos GetFileSize(const char* path, std::streamsize max = std::numeric_limits<std::streamsize>::max());
+
+/** Release all directory locks. This is used for unit testing only, at runtime
+ * the global destructor will take care of the locks.
+ */
+void ReleaseDirectoryLocks();
+
+bool TryCreateDirectories(const fs::path& p);
+fs::path GetDefaultDataDir();
+
+#ifdef WIN32
+fs::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
+#endif
+
+#endif // BITCOIN_UTIL_FS_HELPERS_H
diff --git a/src/util/getuniquepath.cpp b/src/util/getuniquepath.cpp
index 1d8e511c8350..af70cca74270 100644
--- a/src/util/getuniquepath.cpp
+++ b/src/util/getuniquepath.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <random.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 
 fs::path GetUniquePath(const fs::path& base)
diff --git a/src/util/getuniquepath.h b/src/util/getuniquepath.h
index e0c6147876b6..15636523006c 100644
--- a/src/util/getuniquepath.h
+++ b/src/util/getuniquepath.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_UTIL_GETUNIQUEPATH_H
 #define BITCOIN_UTIL_GETUNIQUEPATH_H
 
-#include <fs.h>
+#include <util/fs.h>
 
 /**
  * Helper function for getting a unique path
diff --git a/src/util/readwritefile.cpp b/src/util/readwritefile.cpp
index 5d345b98722d..30003d6b8282 100644
--- a/src/util/readwritefile.cpp
+++ b/src/util/readwritefile.cpp
@@ -5,7 +5,7 @@
 
 #include <util/readwritefile.h>
 
-#include <fs.h>
+#include <util/fs.h>
 
 #include <algorithm>
 #include <cstdio>
diff --git a/src/util/readwritefile.h b/src/util/readwritefile.h
index 73437baf1b7d..6ddfcb4f35a2 100644
--- a/src/util/readwritefile.h
+++ b/src/util/readwritefile.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_UTIL_READWRITEFILE_H
 #define BITCOIN_UTIL_READWRITEFILE_H
 
-#include <fs.h>
+#include <util/fs.h>
 
 #include <limits>
 #include <string>
diff --git a/src/util/settings.cpp b/src/util/settings.cpp
index 421b2be4623c..0048d74a093f 100644
--- a/src/util/settings.cpp
+++ b/src/util/settings.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
+#include <util/fs.h>
 #include <util/settings.h>
 
 #include <tinyformat.h>
diff --git a/src/util/settings.h b/src/util/settings.h
index e97158dc0919..60494671e429 100644
--- a/src/util/settings.h
+++ b/src/util/settings.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_UTIL_SETTINGS_H
 #define BITCOIN_UTIL_SETTINGS_H
 
-#include <fs.h>
+#include <util/fs.h>
 
 #include <map>
 #include <string>
diff --git a/src/util/system.cpp b/src/util/system.cpp
index d769dbd055be..adac0e8ac1c0 100644
--- a/src/util/system.cpp
+++ b/src/util/system.cpp
@@ -10,7 +10,8 @@
 
 #include <chainparamsbase.h>
 #include <ctpl_stl.h>
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <stacktraces.h>
 #include <sync.h>
 #include <util/check.h>
@@ -92,79 +93,6 @@ const char * const BITCOIN_SETTINGS_FILENAME = "settings.json";
 
 ArgsManager gArgs;
 
-/** Mutex to protect dir_locks. */
-static GlobalMutex cs_dir_locks;
-
-/** A map that contains all the currently held directory locks. After
- * successful locking, these will be held here until the global destructor
- * cleans them up and thus automatically unlocks them, or ReleaseDirectoryLocks
- * is called.
- */
-static std::map<std::string, std::unique_ptr<fsbridge::FileLock>> dir_locks GUARDED_BY(cs_dir_locks);
-
-bool LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only)
-{
-    LOCK(cs_dir_locks);
-    fs::path pathLockFile = directory / lockfile_name;
-
-    // If a lock for this directory already exists in the map, don't try to re-lock it
-    if (dir_locks.count(fs::PathToString(pathLockFile))) {
-        return true;
-    }
-
-    // Create empty lock file if it doesn't exist.
-    FILE* file = fsbridge::fopen(pathLockFile, "a");
-    if (file) fclose(file);
-    auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
-    if (!lock->TryLock()) {
-        return error("Error while attempting to lock directory %s: %s", fs::PathToString(directory), lock->GetReason());
-    }
-    if (!probe_only) {
-        // Lock successful and we're not just probing, put it into the map
-        dir_locks.emplace(fs::PathToString(pathLockFile), std::move(lock));
-    }
-    return true;
-}
-
-void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name)
-{
-    LOCK(cs_dir_locks);
-    dir_locks.erase(fs::PathToString(directory / lockfile_name));
-}
-
-void ReleaseDirectoryLocks()
-{
-    LOCK(cs_dir_locks);
-    dir_locks.clear();
-}
-
-bool DirIsWritable(const fs::path& directory)
-{
-    fs::path tmpFile = GetUniquePath(directory);
-
-    FILE* file = fsbridge::fopen(tmpFile, "a");
-    if (!file) return false;
-
-    fclose(file);
-    remove(tmpFile);
-
-    return true;
-}
-
-bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes)
-{
-    constexpr uint64_t min_disk_space = 52428800; // 50 MiB
-
-    uint64_t free_bytes_available = fs::space(dir).available;
-    return free_bytes_available >= min_disk_space + additional_bytes;
-}
-
-std::streampos GetFileSize(const char* path, std::streamsize max) {
-    std::ifstream file{path, std::ios::binary};
-    file.ignore(max);
-    return file.gcount();
-}
-
 /**
  * Interpret a string argument as a boolean.
  *
@@ -1187,171 +1115,6 @@ std::vector<util::SettingsValue> ArgsManager::GetSettingsList(const std::string&
     return util::GetSettingsList(m_settings, m_network, SettingName(arg), !UseDefaultSection(arg));
 }
 
-bool RenameOver(fs::path src, fs::path dest)
-{
-    std::error_code error;
-    fs::rename(src, dest, error);
-    return !error;
-}
-
-/**
- * Ignores exceptions thrown by create_directories if the requested directory exists.
- * Specifically handles case where path p exists, but it wasn't possible for the user to
- * write to the parent directory.
- */
-bool TryCreateDirectories(const fs::path& p)
-{
-    try
-    {
-        return fs::create_directories(p);
-    } catch (const fs::filesystem_error&) {
-        if (!fs::exists(p) || !fs::is_directory(p))
-            throw;
-    }
-
-    // create_directories didn't create the directory, it had to have existed already
-    return false;
-}
-
-bool FileCommit(FILE *file)
-{
-    if (fflush(file) != 0) { // harmless if redundantly called
-        LogPrintf("fflush failed: %s\n", SysErrorString(errno));
-        return false;
-    }
-#ifdef WIN32
-    HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
-    if (FlushFileBuffers(hFile) == 0) {
-        LogPrintf("FlushFileBuffers failed: %s\n", Win32ErrorString(GetLastError()));
-        return false;
-    }
-#elif defined(MAC_OSX) && defined(F_FULLFSYNC)
-    if (fcntl(fileno(file), F_FULLFSYNC, 0) == -1) { // Manpage says "value other than -1" is returned on success
-        LogPrintf("fcntl F_FULLFSYNC failed: %s\n", SysErrorString(errno));
-        return false;
-    }
-#elif HAVE_FDATASYNC
-    if (fdatasync(fileno(file)) != 0 && errno != EINVAL) { // Ignore EINVAL for filesystems that don't support sync
-        LogPrintf("fdatasync failed: %d\n", SysErrorString(errno));
-        return false;
-    }
-#else
-    if (fsync(fileno(file)) != 0 && errno != EINVAL) {
-        LogPrintf("fsync failed: %d\n", SysErrorString(errno));
-        return false;
-    }
-#endif
-    return true;
-}
-
-void DirectoryCommit(const fs::path &dirname)
-{
-#ifndef WIN32
-    FILE* file = fsbridge::fopen(dirname, "r");
-    if (file) {
-        fsync(fileno(file));
-        fclose(file);
-    }
-#endif
-}
-
-bool TruncateFile(FILE *file, unsigned int length) {
-#if defined(WIN32)
-    return _chsize(_fileno(file), length) == 0;
-#else
-    return ftruncate(fileno(file), length) == 0;
-#endif
-}
-
-/**
- * this function tries to raise the file descriptor limit to the requested number.
- * It returns the actual file descriptor limit (which may be more or less than nMinFD)
- */
-int RaiseFileDescriptorLimit(int nMinFD) {
-#if defined(WIN32)
-    return 2048;
-#else
-    struct rlimit limitFD;
-    if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
-        if (limitFD.rlim_cur < (rlim_t)nMinFD) {
-            limitFD.rlim_cur = nMinFD;
-            if (limitFD.rlim_cur > limitFD.rlim_max)
-                limitFD.rlim_cur = limitFD.rlim_max;
-            setrlimit(RLIMIT_NOFILE, &limitFD);
-            getrlimit(RLIMIT_NOFILE, &limitFD);
-        }
-        return limitFD.rlim_cur;
-    }
-    return nMinFD; // getrlimit failed, assume it's fine
-#endif
-}
-
-/**
- * this function tries to make a particular range of a file allocated (corresponding to disk space)
- * it is advisory, and the range specified in the arguments will never contain live data
- */
-void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
-#if defined(WIN32)
-    // Windows-specific version
-    HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
-    LARGE_INTEGER nFileSize;
-    int64_t nEndPos = (int64_t)offset + length;
-    nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
-    nFileSize.u.HighPart = nEndPos >> 32;
-    SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
-    SetEndOfFile(hFile);
-#elif defined(MAC_OSX)
-    // OSX specific version
-    // NOTE: Contrary to other OS versions, the OSX version assumes that
-    // NOTE: offset is the size of the file.
-    fstore_t fst;
-    fst.fst_flags = F_ALLOCATECONTIG;
-    fst.fst_posmode = F_PEOFPOSMODE;
-    fst.fst_offset = 0;
-    fst.fst_length = length; // mac os fst_length takes the # of free bytes to allocate, not desired file size
-    fst.fst_bytesalloc = 0;
-    if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
-        fst.fst_flags = F_ALLOCATEALL;
-        fcntl(fileno(file), F_PREALLOCATE, &fst);
-    }
-    ftruncate(fileno(file), static_cast<off_t>(offset) + length);
-#else
-    #if defined(HAVE_POSIX_FALLOCATE)
-    // Version using posix_fallocate
-    off_t nEndPos = (off_t)offset + length;
-    if (0 == posix_fallocate(fileno(file), 0, nEndPos)) return;
-    #endif
-    // Fallback version
-    // TODO: just write one byte per block
-    static const char buf[65536] = {};
-    if (fseek(file, offset, SEEK_SET)) {
-        return;
-    }
-    while (length > 0) {
-        unsigned int now = 65536;
-        if (length < now)
-            now = length;
-        fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
-        length -= now;
-    }
-#endif
-}
-
-#ifdef WIN32
-fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
-{
-    WCHAR pszPath[MAX_PATH] = L"";
-
-    if(SHGetSpecialFolderPathW(nullptr, pszPath, nFolder, fCreate))
-    {
-        return fs::path(pszPath);
-    }
-
-    LogPrintf("SHGetSpecialFolderPathW() failed, could not obtain requested path.\n");
-    return fs::path("");
-}
-#endif
-
 #ifndef WIN32
 std::string ShellEscape(const std::string& arg)
 {
diff --git a/src/util/system.h b/src/util/system.h
index 08722d5f57bc..ff7640ef73c6 100644
--- a/src/util/system.h
+++ b/src/util/system.h
@@ -18,9 +18,9 @@
 #include <compat/assumptions.h>
 #include <compat/compat.h>
 #include <consensus/amount.h>
-#include <fs.h>
 #include <logging.h>
 #include <sync.h>
+#include <util/fs.h>
 #include <util/settings.h>
 #include <util/time.h>
 
@@ -58,55 +58,10 @@ bool error(const char* fmt, const Args&... args)
 
 void PrintExceptionContinue(const std::exception_ptr pex, const char* pszExceptionOrigin);
 
-/**
- * Ensure file contents are fully committed to disk, using a platform-specific
- * feature analogous to fsync().
- */
-bool FileCommit(FILE *file);
-
-/**
- * Sync directory contents. This is required on some environments to ensure that
- * newly created files are committed to disk.
- */
-void DirectoryCommit(const fs::path &dirname);
-
-bool TruncateFile(FILE *file, unsigned int length);
-int RaiseFileDescriptorLimit(int nMinFD);
-void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length);
-
-/**
- * Rename src to dest.
- * @return true if the rename was successful.
- */
-[[nodiscard]] bool RenameOver(fs::path src, fs::path dest);
-
-bool LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only=false);
-void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name);
-bool DirIsWritable(const fs::path& directory);
-bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes = 0);
-
-/** Get the size of a file by scanning it.
- *
- * @param[in] path The file path
- * @param[in] max Stop seeking beyond this limit
- * @return The file size or max
- */
-std::streampos GetFileSize(const char* path, std::streamsize max = std::numeric_limits<std::streamsize>::max());
-
-/** Release all directory locks. This is used for unit testing only, at runtime
- * the global destructor will take care of the locks.
- */
-/** Dash: We also use this to release locks earlier when restarting the client */
-void ReleaseDirectoryLocks();
-
-bool TryCreateDirectories(const fs::path& p);
 fs::path GetDefaultDataDir();
 // Return true if -datadir option points to a valid directory or is not specified.
 bool CheckDataDirOption();
 fs::path GetConfigFile(const fs::path& configuration_file_path);
-#ifdef WIN32
-fs::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
-#endif
 #ifndef WIN32
 std::string ShellEscape(const std::string& arg);
 #endif
diff --git a/src/validation.cpp b/src/validation.cpp
index 2a16f339b631..95a94efc4304 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -41,6 +41,7 @@
 #include <uint256.h>
 #include <undo.h>
 #include <util/check.h>
+#include <util/fs_helpers.h>
 #include <util/hasher.h>
 #include <util/strencodings.h>
 #include <util/trace.h>
@@ -146,7 +147,7 @@ CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMe
 } // namespace node
 using node::GetTransaction;
 
-const CBlockIndex* CChainState::FindForkInGlobalIndex(const CBlockLocator& locator) const
+const CBlockIndex* Chainstate::FindForkInGlobalIndex(const CBlockLocator& locator) const
 {
     AssertLockHeld(cs_main);
 
@@ -290,7 +291,7 @@ bool CheckSequenceLocksAtTip(CBlockIndex* tip,
     return EvaluateSequenceLocks(index, {lock_points.height, lock_points.time});
 }
 
-bool GetUTXOCoin(CChainState& active_chainstate, const COutPoint& outpoint, Coin& coin)
+bool GetUTXOCoin(Chainstate& active_chainstate, const COutPoint& outpoint, Coin& coin)
 {
     LOCK(cs_main);
     if (!active_chainstate.CoinsTip().GetCoin(outpoint, coin))
@@ -300,14 +301,14 @@ bool GetUTXOCoin(CChainState& active_chainstate, const COutPoint& outpoint, Coin
     return true;
 }
 
-int GetUTXOHeight(CChainState& active_chainstate, const COutPoint& outpoint)
+int GetUTXOHeight(Chainstate& active_chainstate, const COutPoint& outpoint)
 {
     // -1 means UTXO is yet unknown or already spent
     Coin coin;
     return GetUTXOCoin(active_chainstate, outpoint, coin) ? coin.nHeight : -1;
 }
 
-int GetUTXOConfirmations(CChainState& active_chainstate, const COutPoint& outpoint)
+int GetUTXOConfirmations(Chainstate& active_chainstate, const COutPoint& outpoint)
 {
     // -1 means UTXO is yet unknown or already spent
     LOCK(cs_main);
@@ -368,7 +369,7 @@ static void LimitMempoolSize(CTxMemPool& pool, CCoinsViewCache& coins_cache, siz
         coins_cache.Uncache(removed);
 }
 
-static bool IsCurrentForFeeEstimation(CChainState& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+static bool IsCurrentForFeeEstimation(Chainstate& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     AssertLockHeld(cs_main);
     if (active_chainstate.IsInitialBlockDownload())
@@ -381,7 +382,7 @@ static bool IsCurrentForFeeEstimation(CChainState& active_chainstate) EXCLUSIVE_
     return true;
 }
 
-void CChainState::MaybeUpdateMempoolForReorg(
+void Chainstate::MaybeUpdateMempoolForReorg(
     DisconnectedBlockTransactions& disconnectpool,
     bool fAddToMempool)
 {
@@ -528,7 +529,7 @@ namespace {
 class MemPoolAccept
 {
 public:
-    explicit MemPoolAccept(CTxMemPool& mempool, CChainState& active_chainstate) :
+    explicit MemPoolAccept(CTxMemPool& mempool, Chainstate& active_chainstate) :
         m_pool(mempool),
         m_view(&m_dummy),
         m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
@@ -737,7 +738,7 @@ class MemPoolAccept
     CCoinsViewCache m_view;
     CCoinsViewMemPool m_viewmempool;
     CCoinsView m_dummy;
-    CChainState& m_active_chainstate;
+    Chainstate& m_active_chainstate;
     CChainstateHelper& m_chain_helper;
 
     // The package limits in effect at the time of invocation.
@@ -1401,7 +1402,7 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package,
 
 } // anon namespace
 
-MempoolAcceptResult AcceptToMemoryPool(CChainState& active_chainstate, const CTransactionRef& tx,
+MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTransactionRef& tx,
                                        int64_t accept_time, bool bypass_limits, bool test_accept)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 {
@@ -1431,7 +1432,7 @@ MempoolAcceptResult AcceptToMemoryPool(CChainState& active_chainstate, const CTr
     return result;
 }
 
-PackageMempoolAcceptResult ProcessNewPackage(CChainState& active_chainstate, CTxMemPool& pool,
+PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxMemPool& pool,
                                              const Package& package, bool test_accept)
 {
     AssertLockHeld(cs_main);
@@ -1653,7 +1654,7 @@ void CoinsViews::InitCache()
     m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
 }
 
-CChainState::CChainState(CTxMemPool* mempool,
+Chainstate::Chainstate(CTxMemPool* mempool,
                          BlockManager& blockman,
                          ChainstateManager& chainman,
                          CEvoDB& evoDb,
@@ -1667,7 +1668,7 @@ CChainState::CChainState(CTxMemPool* mempool,
       m_chainman(chainman),
       m_from_snapshot_blockhash(from_snapshot_blockhash) {}
 
-void CChainState::InitCoinsDB(
+void Chainstate::InitCoinsDB(
     size_t cache_size_bytes,
     bool in_memory,
     bool should_wipe,
@@ -1681,7 +1682,7 @@ void CChainState::InitCoinsDB(
         leveldb_name, cache_size_bytes, in_memory, should_wipe);
 }
 
-void CChainState::InitCoinsCache(size_t cache_size_bytes)
+void Chainstate::InitCoinsCache(size_t cache_size_bytes)
 {
     AssertLockHeld(::cs_main);
     assert(m_coins_views != nullptr);
@@ -1691,10 +1692,10 @@ void CChainState::InitCoinsCache(size_t cache_size_bytes)
 
 // Note that though this is marked const, we may end up modifying `m_cached_finished_ibd`, which
 // is a performance-related implementation detail. This function must be marked
-// `const` so that `CValidationInterface` clients (which are given a `const CChainState*`)
+// `const` so that `CValidationInterface` clients (which are given a `const Chainstate*`)
 // can call it.
 //
-bool CChainState::IsInitialBlockDownload() const
+bool Chainstate::IsInitialBlockDownload() const
 {
     // Optimization: pre-test latch before taking the lock.
     if (m_cached_finished_ibd.load(std::memory_order_relaxed))
@@ -1736,7 +1737,7 @@ static void AlertNotify(const std::string& strMessage)
 #endif
 }
 
-void CChainState::CheckForkWarningConditions()
+void Chainstate::CheckForkWarningConditions()
 {
     AssertLockHeld(cs_main);
 
@@ -1755,7 +1756,7 @@ void CChainState::CheckForkWarningConditions()
 }
 
 // Called both upon regular invalid block discovery *and* InvalidateBlock
-void CChainState::InvalidChainFound(CBlockIndex* pindexNew)
+void Chainstate::InvalidChainFound(CBlockIndex* pindexNew)
 {
     AssertLockHeld(cs_main);
 
@@ -1779,7 +1780,7 @@ void CChainState::InvalidChainFound(CBlockIndex* pindexNew)
     CheckForkWarningConditions();
 }
 
-void CChainState::ConflictingChainFound(CBlockIndex* pindexNew)
+void Chainstate::ConflictingChainFound(CBlockIndex* pindexNew)
 {
     AssertLockHeld(cs_main);
 
@@ -1798,7 +1799,7 @@ void CChainState::ConflictingChainFound(CBlockIndex* pindexNew)
 
 // Same as InvalidChainFound, above, except not called directly from InvalidateBlock,
 // which does its own setBlockIndexCandidates manageent.
-void CChainState::InvalidBlockFound(CBlockIndex *pindex, const BlockValidationState &state)
+void Chainstate::InvalidBlockFound(CBlockIndex *pindex, const BlockValidationState &state)
 {
     AssertLockHeld(cs_main);
 
@@ -2001,7 +2002,7 @@ int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
 
 /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
  *  When FAILED is returned, view is left in an indeterminate state. */
-DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
+DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
 {
     AssertLockHeld(cs_main);
     assert(m_chain_helper);
@@ -2280,7 +2281,7 @@ static int64_t nBlocksTotal = 0;
 /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
  *  can fail if those validity checks fail (among other reasons). */
-bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
+bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
                                CCoinsViewCache& view, bool fJustCheck)
 {
     int64_t nTimeStart = GetTimeMicros();
@@ -2734,7 +2735,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     return true;
 }
 
-CoinsCacheSizeState CChainState::GetCoinsCacheSizeState()
+CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState()
 {
     AssertLockHeld(::cs_main);
     return this->GetCoinsCacheSizeState(
@@ -2742,7 +2743,7 @@ CoinsCacheSizeState CChainState::GetCoinsCacheSizeState()
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000);
 }
 
-CoinsCacheSizeState CChainState::GetCoinsCacheSizeState(
+CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState(
     size_t max_coins_cache_size_bytes,
     size_t max_mempool_size_bytes)
 {
@@ -2766,7 +2767,7 @@ CoinsCacheSizeState CChainState::GetCoinsCacheSizeState(
     return CoinsCacheSizeState::OK;
 }
 
-bool CChainState::FlushStateToDisk(
+bool Chainstate::FlushStateToDisk(
     BlockValidationState &state,
     FlushStateMode mode,
     int nManualPruneHeight)
@@ -2918,7 +2919,7 @@ bool CChainState::FlushStateToDisk(
     return true;
 }
 
-void CChainState::ForceFlushStateToDisk()
+void Chainstate::ForceFlushStateToDisk()
 {
     BlockValidationState state;
     if (!this->FlushStateToDisk(state, FlushStateMode::ALWAYS)) {
@@ -2926,7 +2927,7 @@ void CChainState::ForceFlushStateToDisk()
     }
 }
 
-void CChainState::PruneAndFlush()
+void Chainstate::PruneAndFlush()
 {
     BlockValidationState state;
     m_blockman.m_check_for_pruning = true;
@@ -2975,7 +2976,7 @@ static void UpdateTipLog(
         !warning_messages.empty() ? strprintf(" warning='%s'", warning_messages) : "");
 }
 
-void CChainState::UpdateTip(const CBlockIndex* pindexNew)
+void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
 {
     AssertLockHeld(::cs_main);
     const auto& coins_tip = this->CoinsTip();
@@ -3032,7 +3033,7 @@ void CChainState::UpdateTip(const CBlockIndex* pindexNew)
   * disconnectpool (note that the caller is responsible for mempool consistency
   * in any case).
   */
-bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool)
+bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool)
 {
     AssertLockHeld(cs_main);
     if (m_mempool) AssertLockHeld(m_mempool->cs);
@@ -3116,7 +3117,7 @@ bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTr
 
 static int64_t nTimeConnectTotal = 0;
 static int64_t nTimeFlush = 0;
-static int64_t nTimeChainState = 0;
+static int64_t nTimeChainstate = 0;
 static int64_t nTimePostConnect = 0;
 
 struct PerBlockConnectTrace {
@@ -3165,7 +3166,7 @@ class ConnectTrace {
  *
  * The block is added to connectTrace if connection succeeds.
  */
-bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool)
+bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool)
 {
     AssertLockHeld(cs_main);
     if (m_mempool) AssertLockHeld(m_mempool->cs);
@@ -3215,8 +3216,8 @@ bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew
     if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
         return false;
     }
-    int64_t nTime5 = GetTimeMicros(); nTimeChainState += nTime5 - nTime4;
-    LogPrint(BCLog::BENCHMARK, "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime5 - nTime4) * MILLI, nTimeChainState * MICRO, nTimeChainState * MILLI / nBlocksTotal);
+    int64_t nTime5 = GetTimeMicros(); nTimeChainstate += nTime5 - nTime4;
+    LogPrint(BCLog::BENCHMARK, "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime5 - nTime4) * MILLI, nTimeChainstate * MICRO, nTimeChainstate * MILLI / nBlocksTotal);
     // Remove conflicting transactions from the mempool.;
     if (m_mempool) {
         m_mempool->removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
@@ -3250,7 +3251,7 @@ bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew
  * Return the tip of the chain with the most work in it, that isn't
  * known to be invalid (it's however far from certain to be valid).
  */
-CBlockIndex* CChainState::FindMostWorkChain()
+CBlockIndex* Chainstate::FindMostWorkChain()
 {
     AssertLockHeld(::cs_main);
     do {
@@ -3313,7 +3314,7 @@ CBlockIndex* CChainState::FindMostWorkChain()
 }
 
 /** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
-void CChainState::PruneBlockIndexCandidates() {
+void Chainstate::PruneBlockIndexCandidates() {
     // Note that we can't delete the current block itself, as we may need to return to it later in case a
     // reorganization to a better block fails.
     std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
@@ -3330,7 +3331,7 @@ void CChainState::PruneBlockIndexCandidates() {
  *
  * @returns true unless a system error occurred
  */
-bool CChainState::ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace)
+bool Chainstate::ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace)
 {
     AssertLockHeld(cs_main);
     if (m_mempool) AssertLockHeld(m_mempool->cs);
@@ -3422,7 +3423,7 @@ static SynchronizationState GetSynchronizationState(bool init)
     return SynchronizationState::INIT_DOWNLOAD;
 }
 
-static bool NotifyHeaderTip(CChainState& chainstate) LOCKS_EXCLUDED(cs_main) {
+static bool NotifyHeaderTip(Chainstate& chainstate) LOCKS_EXCLUDED(cs_main) {
     bool fNotify = false;
     bool fInitialBlockDownload = false;
     static CBlockIndex* pindexHeaderOld = nullptr;
@@ -3453,7 +3454,7 @@ static void LimitValidationInterfaceQueue() LOCKS_EXCLUDED(cs_main) {
     }
 }
 
-bool CChainState::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
+bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
 {
     AssertLockNotHeld(m_chainstate_mutex);
 
@@ -3562,7 +3563,7 @@ bool CChainState::ActivateBestChain(BlockValidationState& state, std::shared_ptr
     return true;
 }
 
-bool CChainState::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
+bool Chainstate::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
 {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
@@ -3593,7 +3594,7 @@ bool CChainState::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex
     return ActivateBestChain(state, std::shared_ptr<const CBlock>());
 }
 
-bool CChainState::InvalidateBlock(BlockValidationState& state, CBlockIndex* pindex)
+bool Chainstate::InvalidateBlock(BlockValidationState& state, CBlockIndex* pindex)
 {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
@@ -3749,7 +3750,7 @@ bool CChainState::InvalidateBlock(BlockValidationState& state, CBlockIndex* pind
     return true;
 }
 
-void CChainState::EnforceBlock(BlockValidationState& state, const CBlockIndex *pindex)
+void Chainstate::EnforceBlock(BlockValidationState& state, const CBlockIndex *pindex)
 {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
@@ -3766,11 +3767,11 @@ void CChainState::EnforceBlock(BlockValidationState& state, const CBlockIndex *p
                 continue;
             }
             if (!MarkConflictingBlock(state, jt->second)) {
-                LogPrintf("CChainState::%s -- MarkConflictingBlock failed: %s\n", __func__, state.ToString());
+                LogPrintf("Chainstate::%s -- MarkConflictingBlock failed: %s\n", __func__, state.ToString());
                 // This should not have happened and we are in a state were it's not safe to continue anymore
                 assert(false);
             }
-            LogPrintf("CChainState::%s -- marked block %s as conflicting\n",
+            LogPrintf("Chainstate::%s -- marked block %s as conflicting\n",
                       __func__, jt->second->GetBlockHash().ToString());
         }
         pindex_walk = pindex_walk->pprev;
@@ -3781,7 +3782,7 @@ void CChainState::EnforceBlock(BlockValidationState& state, const CBlockIndex *p
     }
 }
 
-bool CChainState::MarkConflictingBlock(BlockValidationState& state, CBlockIndex *pindex)
+bool Chainstate::MarkConflictingBlock(BlockValidationState& state, CBlockIndex *pindex)
 {
     AssertLockHeld(cs_main);
 
@@ -3851,7 +3852,7 @@ bool CChainState::MarkConflictingBlock(BlockValidationState& state, CBlockIndex
     return true;
 }
 
-void CChainState::ResetBlockFailureFlags(CBlockIndex *pindex, bool ignore_chainlocks) {
+void Chainstate::ResetBlockFailureFlags(CBlockIndex *pindex, bool ignore_chainlocks) {
     AssertLockHeld(cs_main);
 
     if (!pindex) {
@@ -3921,7 +3922,7 @@ void CChainState::ResetBlockFailureFlags(CBlockIndex *pindex, bool ignore_chainl
 }
 
 /** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */
-void CChainState::ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos)
+void Chainstate::ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos)
 {
     AssertLockHeld(cs_main);
     pindexNew->nTx = block.vtx.size();
@@ -4356,7 +4357,7 @@ bool ChainstateManager::ProcessNewBlockHeaders(const std::vector<CBlockHeader>&
 }
 
 /** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
-bool CChainState::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, const uint256* known_hash)
+bool Chainstate::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, const uint256* known_hash)
 {
     auto start = Now<SteadyMicroseconds>();
 
@@ -4494,7 +4495,7 @@ bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& blo
 
 MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef& tx, bool test_accept, bool bypass_limits)
 {
-    CChainState& active_chainstate = ActiveChainstate();
+    Chainstate& active_chainstate = ActiveChainstate();
     if (!active_chainstate.GetMempool()) {
         TxValidationState state;
         state.Invalid(TxValidationResult::TX_NO_MEMPOOL, "no-mempool");
@@ -4509,7 +4510,7 @@ bool TestBlockValidity(BlockValidationState& state,
                        const chainlock::Chainlocks& chainlocks,
                        CEvoDB& evoDb,
                        const CChainParams& chainparams,
-                       CChainState& chainstate,
+                       Chainstate& chainstate,
                        const CBlock& block,
                        CBlockIndex* pindexPrev,
                        bool fCheckPOW,
@@ -4561,7 +4562,7 @@ bool TestBlockValidity(BlockValidationState& state,
 }
 
 /* This function is called from the RPC code for pruneblockchain */
-void PruneBlockFilesManual(CChainState& active_chainstate, int nManualPruneHeight)
+void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight)
 {
     BlockValidationState state;
     if (!active_chainstate.FlushStateToDisk(state, FlushStateMode::NONE, nManualPruneHeight)) {
@@ -4569,7 +4570,7 @@ void PruneBlockFilesManual(CChainState& active_chainstate, int nManualPruneHeigh
     }
 }
 
-void CChainState::LoadMempool(const ArgsManager& args)
+void Chainstate::LoadMempool(const ArgsManager& args)
 {
     if (!m_mempool) return;
     if (args.GetBoolArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
@@ -4578,7 +4579,7 @@ void CChainState::LoadMempool(const ArgsManager& args)
     m_mempool->SetIsLoaded(!ShutdownRequested());
 }
 
-bool CChainState::LoadChainTip()
+bool Chainstate::LoadChainTip()
 {
     AssertLockHeld(cs_main);
     const CCoinsViewCache& coins_cache = CoinsTip();
@@ -4617,7 +4618,7 @@ CVerifyDB::~CVerifyDB()
 }
 
 bool CVerifyDB::VerifyDB(
-    CChainState& chainstate,
+    Chainstate& chainstate,
     const Consensus::Params& consensus_params,
     CCoinsView& coinsview,
     CEvoDB& evoDb,
@@ -4742,7 +4743,7 @@ bool CVerifyDB::VerifyDB(
 }
 
 /** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */
-bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs)
+bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs)
 {
     AssertLockHeld(cs_main);
 
@@ -4849,7 +4850,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
     return true;
 }
 
-bool CChainState::ReplayBlocks()
+bool Chainstate::ReplayBlocks()
 {
     LOCK(cs_main);
 
@@ -4926,7 +4927,7 @@ bool CChainState::ReplayBlocks()
     return true;
 }
 
-void CChainState::UnloadBlockIndex()
+void Chainstate::UnloadBlockIndex()
 {
     AssertLockHeld(::cs_main);
     nBlockSequenceId = 1;
@@ -4995,7 +4996,7 @@ bool ChainstateManager::LoadBlockIndex()
                 // detecting "holistically" whether the block index under consideration
                 // relied on an assumed-valid ancestor, but this proved to be too slow to
                 // be practical.
-                for (CChainState* chainstate : GetAll()) {
+                for (Chainstate* chainstate : GetAll()) {
                     if (chainstate->reliesOnAssumedValid() ||
                             pindex->nHeight < first_assumed_valid_height) {
                         chainstate->setBlockIndexCandidates.insert(pindex);
@@ -5041,7 +5042,7 @@ void ChainstateManager::InitAdditionalIndexes()
 
 }
 
-bool CChainState::AddGenesisBlock(const CBlock& block, BlockValidationState& state)
+bool Chainstate::AddGenesisBlock(const CBlock& block, BlockValidationState& state)
 {
     FlatFilePos blockPos{m_blockman.SaveBlockToDisk(block, 0, m_chain, nullptr)};
     if (blockPos.IsNull()) {
@@ -5052,7 +5053,7 @@ bool CChainState::AddGenesisBlock(const CBlock& block, BlockValidationState& sta
     return true;
 }
 
-bool CChainState::LoadGenesisBlock()
+bool Chainstate::LoadGenesisBlock()
 {
     LOCK(cs_main);
 
@@ -5085,7 +5086,7 @@ bool CChainState::LoadGenesisBlock()
     return true;
 }
 
-void CChainState::LoadExternalBlockFile(
+void Chainstate::LoadExternalBlockFile(
     FILE* fileIn,
     FlatFilePos* dbp,
     std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
@@ -5253,7 +5254,7 @@ void CChainState::LoadExternalBlockFile(
     LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
 }
 
-void CChainState::CheckBlockIndex()
+void Chainstate::CheckBlockIndex()
 {
     if (!fCheckBlockIndex) {
         return;
@@ -5482,7 +5483,7 @@ void CChainState::CheckBlockIndex()
     assert(nNodes == forward.size());
 }
 
-std::string CChainState::ToString()
+std::string Chainstate::ToString()
 {
     AssertLockHeld(::cs_main);
     CBlockIndex* tip = m_chain.Tip();
@@ -5491,7 +5492,7 @@ std::string CChainState::ToString()
                      tip ? tip->nHeight : -1, tip ? tip->GetBlockHash().ToString() : "null");
 }
 
-bool CChainState::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
+bool Chainstate::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
 {
     AssertLockHeld(::cs_main);
     if (coinstip_size == m_coinstip_cache_size_bytes &&
@@ -5524,7 +5525,7 @@ bool CChainState::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
 
 static const uint64_t MEMPOOL_DUMP_VERSION = 1;
 
-bool LoadMempool(CTxMemPool& pool, CChainState& active_chainstate, FopenFn mockable_fopen_function)
+bool LoadMempool(CTxMemPool& pool, Chainstate& active_chainstate, FopenFn mockable_fopen_function)
 {
     int64_t nExpiryTimeout = gArgs.GetIntArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60;
     FILE* filestr{mockable_fopen_function(gArgs.GetDataDirNet() / "mempool.dat", "rb")};
@@ -5708,10 +5709,10 @@ std::optional<uint256> ChainstateManager::SnapshotBlockhash() const {
     return std::nullopt;
 }
 
-std::vector<CChainState*> ChainstateManager::GetAll()
+std::vector<Chainstate*> ChainstateManager::GetAll()
 {
     LOCK(::cs_main);
-    std::vector<CChainState*> out;
+    std::vector<Chainstate*> out;
 
     if (!IsSnapshotValidated() && m_ibd_chainstate) {
         out.push_back(m_ibd_chainstate.get());
@@ -5724,21 +5725,21 @@ std::vector<CChainState*> ChainstateManager::GetAll()
     return out;
 }
 
-CChainState& ChainstateManager::InitializeChainstate(CTxMemPool* mempool,
+Chainstate& ChainstateManager::InitializeChainstate(CTxMemPool* mempool,
                                                      CEvoDB& evoDb,
                                                      const std::unique_ptr<CChainstateHelper>& chain_helper,
                                                      const std::optional<uint256>& snapshot_blockhash)
 {
     AssertLockHeld(::cs_main);
     bool is_snapshot = snapshot_blockhash.has_value();
-    std::unique_ptr<CChainState>& to_modify =
+    std::unique_ptr<Chainstate>& to_modify =
         is_snapshot ? m_snapshot_chainstate : m_ibd_chainstate;
 
     if (to_modify) {
         throw std::logic_error("should not be overwriting a chainstate");
     }
 
-    to_modify.reset(new CChainState(mempool, m_blockman, *this, evoDb, chain_helper, snapshot_blockhash));
+    to_modify.reset(new Chainstate(mempool, m_blockman, *this, evoDb, chain_helper, snapshot_blockhash));
 
     // Snapshot chainstates and initial IBD chaintates always become active.
     if (is_snapshot || (!is_snapshot && !m_active_chainstate)) {
@@ -5807,7 +5808,7 @@ bool ChainstateManager::ActivateSnapshot(
             static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
     }
 
-    auto snapshot_chainstate = WITH_LOCK(::cs_main, return std::make_unique<CChainState>(
+    auto snapshot_chainstate = WITH_LOCK(::cs_main, return std::make_unique<Chainstate>(
             /*mempool=*/ nullptr, m_blockman, *this,
             this->ActiveChainstate().m_evoDb,
             this->ActiveChainstate().m_chain_helper,
@@ -5862,7 +5863,7 @@ static void FlushSnapshotToDisk(CCoinsViewCache& coins_cache, bool snapshot_load
 }
 
 bool ChainstateManager::PopulateAndValidateSnapshot(
-    CChainState& snapshot_chainstate,
+    Chainstate& snapshot_chainstate,
     AutoFile& coins_file,
     const SnapshotMetadata& metadata)
 {
@@ -5956,7 +5957,7 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
 
     // Important that we set this. This and the coins_cache accesses above are
     // sort of a layer violation, but either we reach into the innards of
-    // CCoinsViewCache here or we have to invert some of the CChainState to
+    // CCoinsViewCache here or we have to invert some of the Chainstate to
     // embed them in a snapshot-activation-specific CCoinsViewCache bulk load
     // method.
     coins_cache.SetBestBlock(base_blockhash);
@@ -6052,7 +6053,7 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
     return true;
 }
 
-CChainState& ChainstateManager::ActiveChainstate() const
+Chainstate& ChainstateManager::ActiveChainstate() const
 {
     LOCK(::cs_main);
     assert(m_active_chainstate);
diff --git a/src/validation.h b/src/validation.h
index 666773994265..8d3f2634da6a 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -17,7 +17,7 @@
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <deploymentstatus.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <node/blockstorage.h>
 #include <policy/feerate.h>
 #include <policy/packages.h>
@@ -46,7 +46,7 @@
 #include <utility>
 #include <vector>
 
-class CChainState;
+class Chainstate;
 class CBlockTreeDB;
 class CChainParams;
 class CEvoDB;
@@ -161,7 +161,7 @@ bool AbortNode(BlockValidationState& state, const std::string& strMessage, const
 double GuessVerificationProgress(const ChainTxData& data, const CBlockIndex* pindex);
 
 /** Prune block files up to a given height */
-void PruneBlockFilesManual(CChainState& active_chainstate, int nManualPruneHeight);
+void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight);
 
 /**
 * Validation result for a single transaction mempool acceptance.
@@ -262,7 +262,7 @@ struct PackageMempoolAcceptResult
  *
  * @returns a MempoolAcceptResult indicating whether the transaction was accepted/rejected with reason.
  */
-MempoolAcceptResult AcceptToMemoryPool(CChainState& active_chainstate, const CTransactionRef& tx,
+MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTransactionRef& tx,
                                        int64_t accept_time, bool bypass_limits, bool test_accept)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
@@ -274,13 +274,13 @@ MempoolAcceptResult AcceptToMemoryPool(CChainState& active_chainstate, const CTr
 * If a transaction fails, validation will exit early and some results may be missing. It is also
 * possible for the package to be partially submitted.
 */
-PackageMempoolAcceptResult ProcessNewPackage(CChainState& active_chainstate, CTxMemPool& pool,
+PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxMemPool& pool,
                                              const Package& txns, bool test_accept)
                                              EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
-bool GetUTXOCoin(CChainState& active_chainstate, const COutPoint& outpoint, Coin& coin);
-int GetUTXOHeight(CChainState& active_chainstate, const COutPoint& outpoint);
-int GetUTXOConfirmations(CChainState& active_chainstate, const COutPoint& outpoint);
+bool GetUTXOCoin(Chainstate& active_chainstate, const COutPoint& outpoint, Coin& coin);
+int GetUTXOHeight(Chainstate& active_chainstate, const COutPoint& outpoint);
+int GetUTXOConfirmations(Chainstate& active_chainstate, const COutPoint& outpoint);
 
 /* Mempool validation helper functions */
 
@@ -378,7 +378,7 @@ bool TestBlockValidity(BlockValidationState& state,
                        const chainlock::Chainlocks& chainlocks,
                        CEvoDB& evoDb,
                        const CChainParams& chainparams,
-                       CChainState& chainstate,
+                       Chainstate& chainstate,
                        const CBlock& block,
                        CBlockIndex* pindexPrev,
                        bool fCheckPOW = true,
@@ -390,7 +390,7 @@ class CVerifyDB {
     CVerifyDB();
     ~CVerifyDB();
     bool VerifyDB(
-        CChainState& chainstate,
+        Chainstate& chainstate,
         const Consensus::Params& consensus_params,
         CCoinsView& coinsview,
         CEvoDB& evoDb,
@@ -406,7 +406,7 @@ enum DisconnectResult {
 
 class ConnectTrace;
 
-/** @see CChainState::FlushStateToDisk */
+/** @see Chainstate::FlushStateToDisk */
 enum class FlushStateMode {
     NONE,
     IF_NEEDED,
@@ -459,7 +459,7 @@ enum class CoinsCacheSizeState
 };
 
 /**
- * CChainState stores and provides an API to update our local knowledge of the
+ * Chainstate stores and provides an API to update our local knowledge of the
  * current best chain.
  *
  * Eventually, the API here is targeted at being exposed externally as a
@@ -472,7 +472,7 @@ enum class CoinsCacheSizeState
  * whereas block information and metadata independent of the current tip is
  * kept in `BlockManager`.
  */
-class CChainState
+class Chainstate
 {
 protected:
     /**
@@ -487,8 +487,8 @@ class CChainState
     arith_uint256 nLastPreciousChainwork = 0;
 
     /**
-     * The ChainState Mutex
-     * A lock that must be held when modifying this ChainState - held in ActivateBestChain() and
+     * The Chainstate Mutex
+     * A lock that must be held when modifying this Chainstate - held in ActivateBestChain() and
      * InvalidateBlock()
      */
     Mutex m_chainstate_mutex;
@@ -514,7 +514,7 @@ class CChainState
 
 public:
     //! Reference to a BlockManager instance which itself is shared across all
-    //! CChainState instances.
+    //! Chainstate instances.
     node::BlockManager& m_blockman;
 
     /** Chain parameters for this chainstate */
@@ -526,7 +526,7 @@ class CChainState
     //! chainstate within deeply nested method calls.
     ChainstateManager& m_chainman;
 
-    explicit CChainState(CTxMemPool* mempool,
+    explicit Chainstate(CTxMemPool* mempool,
                          node::BlockManager& blockman,
                          ChainstateManager& chainman,
                          CEvoDB& evoDb,
@@ -870,7 +870,7 @@ class ChainstateManager
     //! This is especially important when, e.g., calling ActivateBestChain()
     //! on all chainstates because we are not able to hold ::cs_main going into
     //! that call.
-    std::unique_ptr<CChainState> m_ibd_chainstate GUARDED_BY(::cs_main);
+    std::unique_ptr<Chainstate> m_ibd_chainstate GUARDED_BY(::cs_main);
 
     //! A chainstate initialized on the basis of a UTXO snapshot. If this is
     //! non-null, it is always our active chainstate.
@@ -881,7 +881,7 @@ class ChainstateManager
     //! This is especially important when, e.g., calling ActivateBestChain()
     //! on all chainstates because we are not able to hold ::cs_main going into
     //! that call.
-    std::unique_ptr<CChainState> m_snapshot_chainstate GUARDED_BY(::cs_main);
+    std::unique_ptr<Chainstate> m_snapshot_chainstate GUARDED_BY(::cs_main);
 
     //! Points to either the ibd or snapshot chainstate; indicates our
     //! most-work chain.
@@ -892,7 +892,7 @@ class ChainstateManager
     //! This is especially important when, e.g., calling ActivateBestChain()
     //! on all chainstates because we are not able to hold ::cs_main going into
     //! that call.
-    CChainState* m_active_chainstate GUARDED_BY(::cs_main) {nullptr};
+    Chainstate* m_active_chainstate GUARDED_BY(::cs_main) {nullptr};
 
     //! If true, the assumed-valid chainstate has been fully validated
     //! by the background validation chainstate.
@@ -904,7 +904,7 @@ class ChainstateManager
 
     //! Internal helper for ActivateSnapshot().
     [[nodiscard]] bool PopulateAndValidateSnapshot(
-        CChainState& snapshot_chainstate,
+        Chainstate& snapshot_chainstate,
         AutoFile& coins_file,
         const node::SnapshotMetadata& metadata);
 
@@ -917,7 +917,7 @@ class ChainstateManager
         BlockValidationState& state,
         CBlockIndex** ppindex,
         const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    friend CChainState;
+    friend Chainstate;
 
 public:
     explicit ChainstateManager(const CChainParams& chainparams) : m_chainparams{chainparams}, m_blockman{{chainparams}} { }
@@ -969,20 +969,20 @@ class ChainstateManager
     //                                  constructor
     //! @param[in] snapshot_blockhash   If given, signify that this chainstate
     //!                                 is based on a snapshot.
-    CChainState& InitializeChainstate(CTxMemPool* mempool,
+    Chainstate& InitializeChainstate(CTxMemPool* mempool,
                                       CEvoDB& evoDb,
                                       const std::unique_ptr<CChainstateHelper>& chain_helper,
                                       const std::optional<uint256>& snapshot_blockhash = std::nullopt)
         LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! Get all chainstates currently being used.
-    std::vector<CChainState*> GetAll();
+    std::vector<Chainstate*> GetAll();
 
     //! Construct and activate a Chainstate on the basis of UTXO snapshot data.
     //!
     //! Steps:
     //!
-    //! - Initialize an unused CChainState.
+    //! - Initialize an unused Chainstate.
     //! - Load its `CoinsViews` contents from `coins_file`.
     //! - Verify that the hash of the resulting coinsdb matches the expected hash
     //!   per assumeutxo chain parameters.
@@ -995,7 +995,7 @@ class ChainstateManager
         AutoFile& coins_file, const node::SnapshotMetadata& metadata, bool in_memory);
 
     //! The most-work chain.
-    CChainState& ActiveChainstate() const;
+    Chainstate& ActiveChainstate() const;
     CChain& ActiveChain() const { return ActiveChainstate().m_chain; }
     int ActiveHeight() const { return ActiveChain().Height(); }
     CBlockIndex* ActiveTip() const { return ActiveChain().Tip(); }
@@ -1115,7 +1115,7 @@ using FopenFn = std::function<FILE*(const fs::path&, const char*)>;
 bool DumpMempool(const CTxMemPool& pool, FopenFn mockable_fopen_function = fsbridge::fopen, bool skip_file_commit = false);
 
 /** Load the mempool from disk. */
-bool LoadMempool(CTxMemPool& pool, CChainState& active_chainstate, FopenFn mockable_fopen_function = fsbridge::fopen);
+bool LoadMempool(CTxMemPool& pool, Chainstate& active_chainstate, FopenFn mockable_fopen_function = fsbridge::fopen);
 
 /**
  * Return the expected assumeutxo value for a given height, if one exists.
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index 6fb3dafde76f..11273af50d60 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -4,7 +4,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <compat/compat.h>
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <wallet/bdb.h>
 #include <wallet/db.h>
 
diff --git a/src/wallet/bdb.h b/src/wallet/bdb.h
index d23aa281883e..a248cf47fa60 100644
--- a/src/wallet/bdb.h
+++ b/src/wallet/bdb.h
@@ -7,9 +7,9 @@
 #define BITCOIN_WALLET_BDB_H
 
 #include <clientversion.h>
-#include <fs.h>
 #include <serialize.h>
 #include <streams.h>
+#include <util/fs.h>
 #include <util/system.h>
 #include <wallet/db.h>
 
diff --git a/src/wallet/db.cpp b/src/wallet/db.cpp
index 12b0c92dda1f..6d13f7efb454 100644
--- a/src/wallet/db.cpp
+++ b/src/wallet/db.cpp
@@ -4,8 +4,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <fs.h>
 #include <logging.h>
+#include <util/fs.h>
 #include <util/system.h>
 #include <wallet/db.h>
 
diff --git a/src/wallet/db.h b/src/wallet/db.h
index 6d6b556518c4..1b56cde6d8c9 100644
--- a/src/wallet/db.h
+++ b/src/wallet/db.h
@@ -7,9 +7,9 @@
 #define BITCOIN_WALLET_DB_H
 
 #include <clientversion.h>
-#include <fs.h>
 #include <streams.h>
 #include <support/allocators/secure.h>
+#include <util/fs.h>
 
 #include <atomic>
 #include <memory>
diff --git a/src/wallet/dump.cpp b/src/wallet/dump.cpp
index 9112cb0dc125..1f788b13b643 100644
--- a/src/wallet/dump.cpp
+++ b/src/wallet/dump.cpp
@@ -4,7 +4,7 @@
 
 #include <wallet/dump.h>
 
-#include <fs.h>
+#include <util/fs.h>
 #include <util/translation.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
diff --git a/src/wallet/dump.h b/src/wallet/dump.h
index 0c0c05e3db80..ae1cc9b420a8 100644
--- a/src/wallet/dump.h
+++ b/src/wallet/dump.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_WALLET_DUMP_H
 #define BITCOIN_WALLET_DUMP_H
 
-#include <fs.h>
+#include <util/fs.h>
 
 #include <string>
 #include <vector>
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index c5a901aaf09e..48b71250f30a 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -7,7 +7,7 @@
 
 #include <coinjoin/client.h>
 #include <coinjoin/options.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <net.h>
 #include <interfaces/chain.h>
 #include <scheduler.h>
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
index 666516516923..d52b10c34537 100644
--- a/src/wallet/rpc/backup.cpp
+++ b/src/wallet/rpc/backup.cpp
@@ -7,7 +7,7 @@
 #include <chainparams.h>
 #include <clientversion.h>
 #include <core_io.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <merkleblock.h>
diff --git a/src/wallet/salvage.cpp b/src/wallet/salvage.cpp
index 1ee0edd00e8f..eb75f4562025 100644
--- a/src/wallet/salvage.cpp
+++ b/src/wallet/salvage.cpp
@@ -3,8 +3,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
 #include <streams.h>
+#include <util/fs.h>
 #include <util/translation.h>
 #include <wallet/bdb.h>
 #include <wallet/salvage.h>
diff --git a/src/wallet/salvage.h b/src/wallet/salvage.h
index e4822c3c7569..42f2e0bc56c7 100644
--- a/src/wallet/salvage.h
+++ b/src/wallet/salvage.h
@@ -6,8 +6,8 @@
 #ifndef BITCOIN_WALLET_SALVAGE_H
 #define BITCOIN_WALLET_SALVAGE_H
 
-#include <fs.h>
 #include <streams.h>
+#include <util/fs.h>
 
 class ArgsManager;
 struct bilingual_str;
diff --git a/src/wallet/sqlite.cpp b/src/wallet/sqlite.cpp
index a57943527a13..79ca03826e74 100644
--- a/src/wallet/sqlite.cpp
+++ b/src/wallet/sqlite.cpp
@@ -8,8 +8,8 @@
 #include <crypto/common.h>
 #include <logging.h>
 #include <sync.h>
+#include <util/fs_helpers.h>
 #include <util/strencodings.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <wallet/db.h>
 
diff --git a/src/wallet/test/db_tests.cpp b/src/wallet/test/db_tests.cpp
index f61808c549a7..83ee7b48e140 100644
--- a/src/wallet/test/db_tests.cpp
+++ b/src/wallet/test/db_tests.cpp
@@ -4,8 +4,8 @@
 
 #include <boost/test/unit_test.hpp>
 
-#include <fs.h>
 #include <test/util/setup_common.h>
+#include <util/fs.h>
 #include <wallet/bdb.h>
 
 #include <fstream>
diff --git a/src/wallet/test/init_test_fixture.cpp b/src/wallet/test/init_test_fixture.cpp
index ff5dd337cbea..a7ca2251d731 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -2,9 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <fs.h>
 #include <univalue.h>
 #include <util/check.h>
+#include <util/fs.h>
 #include <util/system.h>
 
 #include <fstream>
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 74fce73a52f4..f8a03b61203b 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -13,7 +13,8 @@
 #include <consensus/consensus.h>
 #include <crypto/common.h>
 #include <external_signer.h>
-#include <fs.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <key.h>
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 6a0323990787..a4f61e09a056 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -8,7 +8,7 @@
 #define BITCOIN_WALLET_WALLET_H
 
 #include <consensus/amount.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <governance/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 1b4f566d6a99..d15e6e8758a1 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -7,7 +7,7 @@
 #include <wallet/walletdb.h>
 
 #include <key_io.h>
-#include <fs.h>
+#include <util/fs.h>
 #include <governance/common.h>
 #include <protocol.h>
 #include <serialize.h>
diff --git a/src/wallet/wallettool.cpp b/src/wallet/wallettool.cpp
index e6235f31fd69..31ca5e01f99a 100644
--- a/src/wallet/wallettool.cpp
+++ b/src/wallet/wallettool.cpp
@@ -8,7 +8,7 @@
 
 #include <wallet/wallettool.h>
 
-#include <fs.h>
+#include <util/fs.h>
 #include <util/translation.h>
 #include <util/system.h>
 #include <wallet/dump.h>
diff --git a/src/wallet/walletutil.h b/src/wallet/walletutil.h
index 42a22cd78cdf..15fe0b99602e 100644
--- a/src/wallet/walletutil.h
+++ b/src/wallet/walletutil.h
@@ -5,8 +5,8 @@
 #ifndef BITCOIN_WALLET_WALLETUTIL_H
 #define BITCOIN_WALLET_WALLETUTIL_H
 
-#include <fs.h>
 #include <script/descriptor.h>
+#include <util/fs.h>
 
 #include <vector>
 
diff --git a/test/sanitizer_suppressions/tsan b/test/sanitizer_suppressions/tsan
index 9d9012895b6e..30c00874cec3 100644
--- a/test/sanitizer_suppressions/tsan
+++ b/test/sanitizer_suppressions/tsan
@@ -17,11 +17,11 @@ race:bitcoin-qt
 # deadlock (TODO fix)
 # To reproduce, see:
 # https://github.com/bitcoin/bitcoin/issues/19303#issuecomment-1514926359
-deadlock:CChainState::ConnectTip
+deadlock:Chainstate::ConnectTip
 deadlock:wallet_tests::CreateWallet
 
 # deadlock false positive (see: https://github.com/dashpay/dash/pull/4563)
-deadlock:CChainState::ConnectTip
+deadlock:Chainstate::ConnectTip
 
 # Intentional deadlock in tests
 deadlock:sync_tests::potential_deadlock_detected
diff --git a/test/sanitizer_suppressions/ubsan b/test/sanitizer_suppressions/ubsan
index 1d1f2ad352b5..b2268035bc0f 100644
--- a/test/sanitizer_suppressions/ubsan
+++ b/test/sanitizer_suppressions/ubsan
@@ -52,6 +52,7 @@ unsigned-integer-overflow:EvalScript
 unsigned-integer-overflow:txmempool.cpp
 unsigned-integer-overflow:util/strencodings.cpp
 unsigned-integer-overflow:xoroshiro128plusplus.h
+implicit-integer-sign-change:CBlockPolicyEstimator::processBlockTx
 implicit-integer-sign-change:addrman.h
 implicit-integer-sign-change:bech32.cpp
 implicit-integer-sign-change:compat/stdin.cpp