diff --git a/src/bench/checkblock.cpp b/src/bench/checkblock.cpp
index b4ff0ee3373f..47482e9c8ff1 100644
--- a/src/bench/checkblock.cpp
+++ b/src/bench/checkblock.cpp
@@ -17,7 +17,7 @@
 
 static void DeserializeBlockTest(benchmark::Bench& bench)
 {
-    CDataStream stream(benchmark::data::block813851, SER_NETWORK, PROTOCOL_VERSION);
+    DataStream stream(benchmark::data::block813851);
     std::byte a{0};
     stream.write({&a, 1}); // Prevent compaction
 
@@ -31,7 +31,7 @@ static void DeserializeBlockTest(benchmark::Bench& bench)
 
 static void DeserializeAndCheckBlockTest(benchmark::Bench& bench)
 {
-    CDataStream stream(benchmark::data::block813851, SER_NETWORK, PROTOCOL_VERSION);
+    DataStream stream(benchmark::data::block813851);
     std::byte a{0};
     stream.write({&a, 1}); // Prevent compaction
 
diff --git a/src/blockencodings.cpp b/src/blockencodings.cpp
index b66c98e8e80c..9f1757322066 100644
--- a/src/blockencodings.cpp
+++ b/src/blockencodings.cpp
@@ -164,7 +164,7 @@ ReadStatus PartiallyDownloadedBlock::InitData(const CBlockHeaderAndShortTxIDs& c
             break;
     }
 
-    LogPrint(BCLog::CMPCTBLOCK, "Initialized PartiallyDownloadedBlock for block %s using a cmpctblock of size %lu\n", cmpctblock.header.GetHash().ToString(), GetSerializeSize(cmpctblock, PROTOCOL_VERSION));
+    LogPrint(BCLog::CMPCTBLOCK, "Initialized PartiallyDownloadedBlock for block %s using a cmpctblock of size %lu\n", cmpctblock.header.GetHash().ToString(), GetSerializeSize(cmpctblock));
 
     return READ_STATUS_OK;
 }
diff --git a/src/coins.cpp b/src/coins.cpp
index 0aa3bf708484..6e37bd390e50 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -8,7 +8,6 @@
 #include <logging.h>
 #include <random.h>
 #include <util/trace.h>
-#include <version.h>
 
 bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const { return false; }
 uint256 CCoinsView::GetBestBlock() const { return uint256(); }
@@ -339,7 +338,7 @@ void CCoinsViewCache::SanityCheck() const
     assert(recomputed_usage == cachedCoinsUsage);
 }
 
-static const size_t MAX_OUTPUTS_PER_BLOCK = MaxBlockSize() /  ::GetSerializeSize(CTxOut(), PROTOCOL_VERSION);
+static const size_t MAX_OUTPUTS_PER_BLOCK = MaxBlockSize() /  ::GetSerializeSize(CTxOut());
 
 const Coin& AccessByTxid(const CCoinsViewCache& view, const uint256& txid)
 {
diff --git a/src/core_read.cpp b/src/core_read.cpp
index 9f7c198d3f9e..86d8f6091d39 100644
--- a/src/core_read.cpp
+++ b/src/core_read.cpp
@@ -13,7 +13,6 @@
 #include <univalue.h>
 #include <util/string.h>
 #include <util/strencodings.h>
-#include <version.h>
 
 #include <algorithm>
 #include <string>
diff --git a/src/hash.h b/src/hash.h
index 5dad7c72bcf7..a2ace4c9040e 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -14,7 +14,6 @@
 #include <prevector.h>
 #include <serialize.h>
 #include <uint256.h>
-#include <version.h>
 
 #include <string>
 #include <vector>
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index f21b8afe4b43..33848d909a60 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -176,8 +176,8 @@ size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilter&
     assert(filter.GetFilterType() == GetFilterType());
 
     size_t data_size =
-        GetSerializeSize(filter.GetBlockHash(), CLIENT_VERSION) +
-        GetSerializeSize(filter.GetEncodedFilter(), CLIENT_VERSION);
+        GetSerializeSize(filter.GetBlockHash()) +
+        GetSerializeSize(filter.GetEncodedFilter());
 
     // If writing the filter would overflow the file, flush and move to the next one.
     if (pos.nPos + data_size > MAX_FLTR_FILE_SIZE) {
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 0a5ca022fa73..d8dbed4bc9a6 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -493,7 +493,7 @@ static bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const
     }
 
     // Write index header
-    unsigned int nSize = GetSerializeSize(blockundo, fileout.GetVersion());
+    unsigned int nSize = GetSerializeSize(blockundo);
     fileout << messageStart << nSize;
 
     // Write undo data
@@ -719,7 +719,7 @@ bool BlockManager::WriteUndoDataForBlock(const CBlockUndo& blockundo, BlockValid
     // Write undo information to disk
     if (pindex->GetUndoPos().IsNull()) {
         FlatFilePos _pos;
-        if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo, CLIENT_VERSION) + 40)) {
+        if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo) + 40)) {
             return error("ConnectBlock(): FindUndoPos failed");
         }
         if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart())) {
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index a56f8c3677f4..3c7c4592fc20 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -12,7 +12,6 @@
 #include <tinyformat.h>
 #include <uint256.h>
 #include <util/strencodings.h>
-#include <version.h>
 
 #include <cassert>
 #include <stdexcept>
diff --git a/src/psbt.cpp b/src/psbt.cpp
index 90285c414ee8..c707e2d79ec8 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -10,6 +10,7 @@
 #include <tinyformat.h>
 #include <util/check.h>
 #include <util/strencodings.h>
+#include <version.h>
 
 #include <numeric>
 
diff --git a/src/psbt.h b/src/psbt.h
index d3d778d8952a..8c2ef582baa7 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -77,7 +77,9 @@ struct PSBTProprietary
 template<typename Stream, typename... X>
 void SerializeToVector(Stream& s, const X&... args)
 {
-    WriteCompactSize(s, GetSerializeSizeMany(s.GetVersion(), args...));
+    SizeComputer sizecomp;
+    SerializeMany(sizecomp, args...);
+    WriteCompactSize(s, sizecomp.size());
     SerializeMany(s, args...);
 }
 
diff --git a/src/rest.cpp b/src/rest.cpp
index e58a650689f6..b10fb6c8aefb 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -30,7 +30,6 @@
 #include <txmempool.h>
 #include <util/check.h>
 #include <validation.h>
-#include <version.h>
 
 #include <string>
 
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 084849d6a8bd..b46834e772bc 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -2085,7 +2085,7 @@ static RPCHelpMan getblockstats()
             for (const CTxOut& out : tx->vout) {
                 tx_total_out += out.nValue;
 
-                size_t out_size = GetSerializeSize(out, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
+                size_t out_size = GetSerializeSize(out) + PER_UTXO_OVERHEAD;
                 utxo_size_inc += out_size;
 
                 // The Genesis block and the repeated BIP30 block coinbases don't change the UTXO
@@ -2125,7 +2125,7 @@ static RPCHelpMan getblockstats()
                 const CTxOut& prevoutput = coin.out;
 
                 tx_total_in += prevoutput.nValue;
-                size_t prevout_size = GetSerializeSize(prevoutput, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
+                size_t prevout_size = GetSerializeSize(prevoutput) + PER_UTXO_OVERHEAD;
                 utxo_size_inc -= prevout_size;
                 utxo_size_inc_actual -= prevout_size;
             }
diff --git a/src/script/bitcoinconsensus.cpp b/src/script/bitcoinconsensus.cpp
index 8f979a0c26b0..7efea1f853ca 100644
--- a/src/script/bitcoinconsensus.cpp
+++ b/src/script/bitcoinconsensus.cpp
@@ -8,7 +8,6 @@
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/interpreter.h>
-#include <version.h>
 
 namespace {
 
diff --git a/src/serialize.h b/src/serialize.h
index d0ac4e8f8917..0ed63c4d60e0 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -129,7 +129,7 @@ template<typename Stream> inline uint64_t ser_readdata64(Stream &s)
 // i.e. anything that supports .read(Span<std::byte>) and .write(Span<const std::byte>)
 //
 
-class CSizeComputer;
+class SizeComputer;
 
 enum
 {
@@ -250,7 +250,7 @@ inline unsigned int GetSizeOfCompactSize(uint64_t nSize)
     else                         return sizeof(unsigned char) + sizeof(uint64_t);
 }
 
-inline void WriteCompactSize(CSizeComputer& os, uint64_t nSize);
+inline void WriteCompactSize(SizeComputer& os, uint64_t nSize);
 
 template<typename Stream>
 void WriteCompactSize(Stream& os, uint64_t nSize)
@@ -376,7 +376,7 @@ inline unsigned int GetSizeOfVarInt(I n)
 }
 
 template<typename I>
-inline void WriteVarInt(CSizeComputer& os, I n);
+inline void WriteVarInt(SizeComputer& os, I n);
 
 template<typename Stream, VarIntMode Mode, typename I>
 void WriteVarInt(Stream& os, I n)
@@ -516,7 +516,7 @@ struct CFixedVarIntsBitSet
 };
 
 /* Forward declaration for WriteAutoBitSet */
-template <typename T> size_t GetSerializeSize(const T& t, int nVersion = 0);
+template <typename T> size_t GetSerializeSize(const T& t);
 
 template<typename Stream>
 void WriteAutoBitSet(Stream& s, const autobitset_t& item)
@@ -526,8 +526,8 @@ void WriteAutoBitSet(Stream& s, const autobitset_t& item)
 
     assert(vec.size() == size);
 
-    size_t size1 = ::GetSerializeSize(CFixedBitSet(vec, size), s.GetVersion());
-    size_t size2 = ::GetSerializeSize(CFixedVarIntsBitSet(vec, size), s.GetVersion());
+    size_t size1 = ::GetSerializeSize(CFixedBitSet(vec, size));
+    size_t size2 = ::GetSerializeSize(CFixedVarIntsBitSet(vec, size));
 
     assert(size1 == GetSizeOfFixedBitSet(size));
 
@@ -1336,22 +1336,21 @@ struct CSerActionUnserialize
 /* ::GetSerializeSize implementations
  *
  * Computing the serialized size of objects is done through a special stream
- * object of type CSizeComputer, which only records the number of bytes written
+ * object of type SizeComputer, which only records the number of bytes written
  * to it.
  *
  * If your Serialize or SerializationOp method has non-trivial overhead for
  * serialization, it may be worthwhile to implement a specialized version for
- * CSizeComputer, which uses the s.seek() method to record bytes that would
+ * SizeComputer, which uses the s.seek() method to record bytes that would
  * be written instead.
  */
-class CSizeComputer
+class SizeComputer
 {
 protected:
     size_t nSize;
 
-    const int nVersion;
 public:
-    explicit CSizeComputer(int nVersionIn) : nSize(0), nVersion(nVersionIn) {}
+    SizeComputer() : nSize(0) {}
 
     void write(Span<const std::byte> src)
     {
@@ -1365,7 +1364,7 @@ class CSizeComputer
     }
 
     template<typename T>
-    CSizeComputer& operator<<(const T& obj)
+    SizeComputer& operator<<(const T& obj)
     {
         ::Serialize(*this, obj);
         return (*this);
@@ -1374,8 +1373,6 @@ class CSizeComputer
     size_t size() const {
         return nSize;
     }
-
-    int GetVersion() const { return nVersion; }
 };
 
 template <typename Stream, typename... Args>
@@ -1425,28 +1422,20 @@ inline void SerWrite(Stream& s, CSerActionUnserialize ser_action, Type&&, Fn&&)
 }
 
 template<typename I>
-inline void WriteVarInt(CSizeComputer &s, I n)
+inline void WriteVarInt(SizeComputer &s, I n)
 {
     s.seek(GetSizeOfVarInt<I>(n));
 }
 
-inline void WriteCompactSize(CSizeComputer &s, uint64_t nSize)
+inline void WriteCompactSize(SizeComputer &s, uint64_t nSize)
 {
     s.seek(GetSizeOfCompactSize(nSize));
 }
 
 template <typename T>
-size_t GetSerializeSize(const T& t, int nVersion)
-{
-    return (CSizeComputer(nVersion) << t).size();
-}
-
-template <typename... T>
-size_t GetSerializeSizeMany(int nVersion, const T&... t)
+size_t GetSerializeSize(const T& t)
 {
-    CSizeComputer sc(nVersion);
-    SerializeMany(sc, t...);
-    return sc.size();
+    return (SizeComputer() << t).size();
 }
 
 #endif // BITCOIN_SERIALIZE_H
diff --git a/src/test/flatfile_tests.cpp b/src/test/flatfile_tests.cpp
index bdc64a93d4f9..1f3441ecb558 100644
--- a/src/test/flatfile_tests.cpp
+++ b/src/test/flatfile_tests.cpp
@@ -40,7 +40,7 @@ BOOST_AUTO_TEST_CASE(flatfile_open)
                       "lost if a trusted third party is still required to prevent double-spending.");
 
     size_t pos1 = 0;
-    size_t pos2 = pos1 + GetSerializeSize(line1, CLIENT_VERSION);
+    size_t pos2 = pos1 + GetSerializeSize(line1);
 
     // Write first line to file.
     {
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index d0b6cc774ccf..0d7514878d1a 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -61,29 +61,31 @@ class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle
 
 BOOST_AUTO_TEST_CASE(sizes)
 {
-    BOOST_CHECK_EQUAL(sizeof(unsigned char), GetSerializeSize((unsigned char)0, 0));
-    BOOST_CHECK_EQUAL(sizeof(int8_t), GetSerializeSize(int8_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(uint8_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(int16_t), GetSerializeSize(int16_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(uint16_t), GetSerializeSize(uint16_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(int32_t), GetSerializeSize(int32_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(uint32_t), GetSerializeSize(uint32_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(int64_t), GetSerializeSize(int64_t(0), 0));
-    BOOST_CHECK_EQUAL(sizeof(uint64_t), GetSerializeSize(uint64_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(unsigned char), GetSerializeSize((unsigned char)0));
+    BOOST_CHECK_EQUAL(sizeof(int8_t), GetSerializeSize(int8_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(uint8_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(int16_t), GetSerializeSize(int16_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(uint16_t), GetSerializeSize(uint16_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(int32_t), GetSerializeSize(int32_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(uint32_t), GetSerializeSize(uint32_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(int64_t), GetSerializeSize(int64_t(0)));
+    BOOST_CHECK_EQUAL(sizeof(uint64_t), GetSerializeSize(uint64_t(0)));
     // Bool is serialized as uint8_t
-    BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(bool(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(bool(0)));
 
     // Sanity-check GetSerializeSize and c++ type matching
-    BOOST_CHECK_EQUAL(GetSerializeSize((unsigned char)0, 0), 1U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(int8_t(0), 0), 1U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(uint8_t(0), 0), 1U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(int16_t(0), 0), 2U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(uint16_t(0), 0), 2U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(int32_t(0), 0), 4U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(uint32_t(0), 0), 4U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(int64_t(0), 0), 8U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(uint64_t(0), 0), 8U);
-    BOOST_CHECK_EQUAL(GetSerializeSize(bool(0), 0), 1U);
+    BOOST_CHECK_EQUAL(GetSerializeSize((unsigned char)0), 1U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int8_t(0)), 1U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint8_t(0)), 1U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int16_t(0)), 2U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint16_t(0)), 2U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int32_t(0)), 4U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint32_t(0)), 4U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int64_t(0)), 8U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint64_t(0)), 8U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(bool(0)), 1U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(std::array<uint8_t, 1>{0}), 1U);
+    BOOST_CHECK_EQUAL(GetSerializeSize(std::array<uint8_t, 2>{0, 0}), 2U);
 }
 
 BOOST_AUTO_TEST_CASE(varints)
@@ -94,13 +96,13 @@ BOOST_AUTO_TEST_CASE(varints)
     CDataStream::size_type size = 0;
     for (int i = 0; i < 100000; i++) {
         ss << VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED);
-        size += ::GetSerializeSize(VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED), 0);
+        size += ::GetSerializeSize(VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED));
         BOOST_CHECK(size == ss.size());
     }
 
     for (uint64_t i = 0;  i < 100000000000ULL; i += 999999937) {
         ss << VARINT(i);
-        size += ::GetSerializeSize(VARINT(i), 0);
+        size += ::GetSerializeSize(VARINT(i));
         BOOST_CHECK(size == ss.size());
     }
 
diff --git a/src/test/uint256_tests.cpp b/src/test/uint256_tests.cpp
index d789fc9f8f19..11c946d187fa 100644
--- a/src/test/uint256_tests.cpp
+++ b/src/test/uint256_tests.cpp
@@ -184,8 +184,8 @@ BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 G
     BOOST_CHECK(OneL.begin() + 32 == OneL.end());
     BOOST_CHECK(MaxL.begin() + 32 == MaxL.end());
     BOOST_CHECK(TmpL.begin() + 32 == TmpL.end());
-    BOOST_CHECK(GetSerializeSize(R1L, PROTOCOL_VERSION) == 32);
-    BOOST_CHECK(GetSerializeSize(ZeroL, PROTOCOL_VERSION) == 32);
+    BOOST_CHECK(GetSerializeSize(R1L) == 32);
+    BOOST_CHECK(GetSerializeSize(ZeroL) == 32);
 
     CDataStream ss(0, PROTOCOL_VERSION);
     ss << R1L;
@@ -230,8 +230,8 @@ BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 G
     BOOST_CHECK(OneS.begin() + 20 == OneS.end());
     BOOST_CHECK(MaxS.begin() + 20 == MaxS.end());
     BOOST_CHECK(TmpS.begin() + 20 == TmpS.end());
-    BOOST_CHECK(GetSerializeSize(R1S, PROTOCOL_VERSION) == 20);
-    BOOST_CHECK(GetSerializeSize(ZeroS, PROTOCOL_VERSION) == 20);
+    BOOST_CHECK(GetSerializeSize(R1S) == 20);
+    BOOST_CHECK(GetSerializeSize(ZeroS) == 20);
 
     ss << R1S;
     BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
diff --git a/src/undo.h b/src/undo.h
index a98f046735ce..1fb9ac06880f 100644
--- a/src/undo.h
+++ b/src/undo.h
@@ -11,7 +11,6 @@
 #include <consensus/consensus.h>
 #include <primitives/transaction.h>
 #include <serialize.h>
-#include <version.h>
 
 /** Formatter for undo information for a CTxIn
  *
diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp
index ef1012689961..20af5e66bba6 100644
--- a/src/wallet/rpc/spend.cpp
+++ b/src/wallet/rpc/spend.cpp
@@ -14,6 +14,7 @@
 #include <wallet/rpc/util.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
+#include <version.h>
 
 #include <univalue.h>
 
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index fe2bb67acab8..97df9d53a41d 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -801,7 +801,7 @@ static std::optional<CreatedTransactionResult> CreateTransactionInternal(
 
         // Include the fee cost for outputs.
         if (!coin_selection_params.m_subtract_fee_outputs) {
-            coin_selection_params.tx_noinputs_size += ::GetSerializeSize(txout, PROTOCOL_VERSION);
+            coin_selection_params.tx_noinputs_size += ::GetSerializeSize(txout);
         }
 
         if (IsDust(txout, wallet.chain().relayDustFee()))
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
index 82e0a5660a2f..ee1d2852ec0a 100644
--- a/src/zmq/zmqpublishnotifier.cpp
+++ b/src/zmq/zmqpublishnotifier.cpp
@@ -9,6 +9,8 @@
 #include <netbase.h>
 #include <node/blockstorage.h>
 #include <streams.h>
+#include <sync.h>
+#include <uint256.h>
 
 #include <chainlock/clsig.h>
 #include <governance/common.h>