backport: v0.26 bitcoin#25284, bitcoin#28470, bitcoin#28473, bitcoin#27784

src/addrdb.cpp

@@ -52,16 +52,16 @@ bool SerializeDB(Stream& stream, const Data& data)
 }
 
 template <typename Data>
-bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data& data, int version)
+bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data& data)
 {
     // Generate random temporary filename
     const uint16_t randv{GetRand<uint16_t>()};
     std::string tmpfn = strprintf("%s.%04x", prefix, randv);
 
-    // open temp output file, and associate with CAutoFile
+    // open temp output file
     fs::path pathTmp = gArgs.GetDataDirNet() / fs::u8path(tmpfn);
     FILE *file = fsbridge::fopen(pathTmp, "wb");
-    CAutoFile fileout(file, SER_DISK, version);
+    AutoFile fileout{file};
     if (fileout.IsNull()) {
         fileout.fclose();
         remove(pathTmp);
@@ -94,9 +94,9 @@ bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data
 }
 
 template <typename Stream, typename Data>
-void DeserializeDB(Stream& stream, Data& data, bool fCheckSum = true)
+void DeserializeDB(Stream& stream, Data&& data, bool fCheckSum = true)
 {
-    CHashVerifier<Stream> verifier(&stream);
+    HashVerifier verifier{stream};
     // de-serialize file header (network specific magic number) and ..
     unsigned char pchMsgTmp[4];
     verifier >> pchMsgTmp;
@@ -119,11 +119,10 @@ void DeserializeDB(Stream& stream, Data& data, bool fCheckSum = true)
 }
 
 template <typename Data>
-void DeserializeFileDB(const fs::path& path, Data& data, int version)
+void DeserializeFileDB(const fs::path& path, Data&& data)
 {
-    // open input file, and associate with CAutoFile
     FILE* file = fsbridge::fopen(path, "rb");
-    CAutoFile filein(file, SER_DISK, version);
+    AutoFile filein{file};
     if (filein.IsNull()) {
         throw DbNotFoundError{};
     }
@@ -183,10 +182,10 @@ bool CBanDB::Read(banmap_t& banSet)
 bool DumpPeerAddresses(const ArgsManager& args, const AddrMan& addr)
 {
     const auto pathAddr = gArgs.GetDataDirNet() / "peers.dat";
-    return SerializeFileDB("peers", pathAddr, addr, CLIENT_VERSION);
+    return SerializeFileDB("peers", pathAddr, addr);
 }
 
-void ReadFromStream(AddrMan& addr, CDataStream& ssPeers)
+void ReadFromStream(AddrMan& addr, DataStream& ssPeers)
 {
     DeserializeDB(ssPeers, addr, false);
 }
@@ -199,7 +198,7 @@ util::Result<std::unique_ptr<AddrMan>> LoadAddrman(const NetGroupManager& netgro
     const auto start{SteadyClock::now()};
     const auto path_addr{gArgs.GetDataDirNet() / "peers.dat"};
     try {
-        DeserializeFileDB(path_addr, *addrman, CLIENT_VERSION);
+        DeserializeFileDB(path_addr, *addrman);
         LogPrintf("Loaded %i addresses from peers.dat  %dms\n", addrman->Size(), Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
     } catch (const DbNotFoundError&) {
         // Addrman can be in an inconsistent state after failure, reset it
@@ -233,14 +232,14 @@ util::Result<std::unique_ptr<AddrMan>> LoadAddrman(const NetGroupManager& netgro
 void DumpAnchors(const fs::path& anchors_db_path, const std::vector<CAddress>& anchors)
 {
     LOG_TIME_SECONDS(strprintf("Flush %d outbound block-relay-only peer addresses to anchors.dat", anchors.size()));
-    SerializeFileDB("anchors", anchors_db_path, anchors, CLIENT_VERSION | ADDRV2_FORMAT);
+    SerializeFileDB("anchors", anchors_db_path, CAddress::V2_DISK(anchors));
 }
 
 std::vector<CAddress> ReadAnchors(const fs::path& anchors_db_path)
 {
     std::vector<CAddress> anchors;
     try {
-        DeserializeFileDB(anchors_db_path, anchors, CLIENT_VERSION | ADDRV2_FORMAT);
+        DeserializeFileDB(anchors_db_path, CAddress::V2_DISK(anchors));
         LogPrintf("Loaded %i addresses from %s\n", anchors.size(), fs::quoted(fs::PathToString(anchors_db_path.filename())));
     } catch (const std::exception&) {
         anchors.clear();

src/addrdb.h

@@ -18,13 +18,14 @@
 class ArgsManager;
 class AddrMan;
 class CAddress;
-class CDataStream;
+class DataStream;
 class NetGroupManager;
 struct bilingual_str;
 
-bool DumpPeerAddresses(const ArgsManager& args, const AddrMan& addr);
 /** Only used by tests. */
-void ReadFromStream(AddrMan& addr, CDataStream& ssPeers);
+void ReadFromStream(AddrMan& addr, DataStream& ssPeers);
+
+bool DumpPeerAddresses(const ArgsManager& args, const AddrMan& addr);
 
 /** Access to the banlist database (banlist.json) */
 class CBanDB

src/addrman.cpp

@@ -175,8 +175,7 @@ void AddrManImpl::Serialize(Stream& s_) const
      */
 
     // Always serialize in the latest version (FILE_FORMAT).
-
-    OverrideStream<Stream> s(&s_, s_.GetType(), s_.GetVersion() | ADDRV2_FORMAT);
+    ParamsStream s{CAddress::V2_DISK, s_};
 
     s << static_cast<uint8_t>(FILE_FORMAT);
 
@@ -240,14 +239,8 @@ void AddrManImpl::Unserialize(Stream& s_)
     Format format;
     s_ >> Using<CustomUintFormatter<1>>(format);
 
-    int stream_version = s_.GetVersion();
-    if (format >= Format::V3_BIP155) {
-        // Add ADDRV2_FORMAT to the version so that the CNetAddr and CAddress
-        // unserialize methods know that an address in addrv2 format is coming.
-        stream_version |= ADDRV2_FORMAT;
-    }
-
-    OverrideStream<Stream> s(&s_, s_.GetType(), stream_version);
+    const auto ser_params = (format >= Format::V3_BIP155 ? CAddress::V2_DISK : CAddress::V1_DISK);
+    ParamsStream s{ser_params, s_};
 
     uint8_t compat;
     s >> compat;
@@ -1310,12 +1303,12 @@ void AddrMan::Unserialize(Stream& s_)
 }
 
 // explicit instantiation
-template void AddrMan::Serialize(HashedSourceWriter<CAutoFile>& s) const;
-template void AddrMan::Serialize(CDataStream& s) const;
-template void AddrMan::Unserialize(CAutoFile& s);
-template void AddrMan::Unserialize(CHashVerifier<CAutoFile>& s);
-template void AddrMan::Unserialize(CDataStream& s);
-template void AddrMan::Unserialize(CHashVerifier<CDataStream>& s);
+template void AddrMan::Serialize(HashedSourceWriter<AutoFile>&) const;
+template void AddrMan::Serialize(DataStream&) const;
+template void AddrMan::Unserialize(AutoFile&);
+template void AddrMan::Unserialize(HashVerifier<AutoFile>&);
+template void AddrMan::Unserialize(DataStream&);
+template void AddrMan::Unserialize(HashVerifier<DataStream>&);
 
 size_t AddrMan::Size(std::optional<Network> net, std::optional<bool> in_new) const
 {

src/addrman_impl.h

@@ -65,8 +65,7 @@ class AddrInfo : public CAddress
 
     SERIALIZE_METHODS(AddrInfo, obj)
     {
-        READWRITEAS(CAddress, obj);
-        READWRITE(obj.source, Using<ChronoFormatter<int64_t>>(obj.m_last_success), obj.nAttempts);
+        READWRITE(AsBase<CAddress>(obj), obj.source, Using<ChronoFormatter<int64_t>>(obj.m_last_success), obj.nAttempts);
     }
 
     AddrInfo(const CAddress &addrIn, const CNetAddr &addrSource) : CAddress(addrIn), source(addrSource)

src/evo/deterministicmns.h

@@ -118,13 +118,13 @@ void UnserializeImmerMap(Stream& is, immer::map<K, T, Hash, Equal>& m)
 // For some reason the compiler is not able to choose the correct Serialize/Deserialize methods without a specialized
 // version of SerReadWrite. It otherwise always chooses the version that calls a.Serialize()
 template<typename Stream, typename K, typename T, typename Hash, typename Equal>
-inline void SerReadWrite(Stream& s, const immer::map<K, T, Hash, Equal>& m, CSerActionSerialize ser_action)
+inline void SerReadWrite(Stream& s, const immer::map<K, T, Hash, Equal>& m, ActionSerialize ser_action)
 {
     ::SerializeImmerMap(s, m);
 }
 
 template<typename Stream, typename K, typename T, typename Hash, typename Equal>
-inline void SerReadWrite(Stream& s, immer::map<K, T, Hash, Equal>& obj, CSerActionUnserialize ser_action)
+inline void SerReadWrite(Stream& s, immer::map<K, T, Hash, Equal>& obj, ActionUnserialize ser_action)
 {
     ::UnserializeImmerMap(s, obj);
 }
@@ -234,7 +234,7 @@ class CDeterministicMNList
     template<typename Stream>
     void Serialize(Stream& s) const
     {
-        const_cast<CDeterministicMNList*>(this)->SerializationOpBase(s, CSerActionSerialize());
+        const_cast<CDeterministicMNList*>(this)->SerializationOpBase(s, ActionSerialize());
 
         // Serialize the map as a vector
         WriteCompactSize(s, mnMap.size());
@@ -248,7 +248,7 @@ class CDeterministicMNList
     {
         Clear();
 
-        SerializationOpBase(s, CSerActionUnserialize());
+        SerializationOpBase(s, ActionUnserialize());
 
         for (size_t to_read = ReadCompactSize(s); to_read > 0; --to_read) {
             AddMN(std::make_shared<CDeterministicMN>(deserialize, s), /*fBumpTotalCount=*/false);
@@ -534,17 +534,16 @@ class CDeterministicMNList
         DMNL_NO_TEMPLATE(NetInfoInterface);
         DMNL_NO_TEMPLATE(std::shared_ptr<NetInfoInterface>);
 #undef DMNL_NO_TEMPLATE
-        int ser_version{PROTOCOL_VERSION};
         if constexpr (std::is_same_v<std::decay_t<T>, CService>) {
             // Special handling is required if we're using addresses that can only be (de)serialized using
             // ADDRv2. Without this step, the address gets truncated, the hashmap gets contaminated with
             // an invalid entry and subsequent attempts at registering ADDRv2 entries get blocked. We cannot
             // apply this treatment ADDRv1 compatible addresses for backwards compatibility with the existing map.
-            if (!v.IsAddrV1Compatible()) {
-                ser_version |= ADDRV2_FORMAT;
-            }
+            const auto& ser_params{v.IsAddrV1Compatible() ? CNetAddr::V1 : CNetAddr::V2};
+            return ::SerializeHash(WithParams(ser_params, v), /*nType=*/SER_GETHASH, /*nVersion=*/PROTOCOL_VERSION);
+        } else {
+            return ::SerializeHash(v, /*nType=*/SER_GETHASH, /*nVersion=*/PROTOCOL_VERSION);
         }
-        return ::SerializeHash(v, /*nType=*/SER_GETHASH, /*nVersion=*/ser_version);
     }
     template <typename T>
     [[nodiscard]] bool AddUniqueProperty(const CDeterministicMN& dmn, const T& v)

src/evo/netinfo.h

@@ -225,12 +225,11 @@ class NetInfoEntry
     bool operator!=(const NetInfoEntry& rhs) const { return !(*this == rhs); }
 
     template <typename Stream>
-    void Serialize(Stream& s_) const
+    void Serialize(Stream& s) const
     {
-        OverrideStream<Stream> s(&s_, /*nType=*/0, s_.GetVersion() | ADDRV2_FORMAT);
         if (const auto* data_ptr_service{std::get_if<CService>(&m_data)};
             m_type == NetInfoType::Service && data_ptr_service && data_ptr_service->IsValid()) {
-            s << m_type << *data_ptr_service;
+            s << m_type << WithParams(CNetAddr::V2, *data_ptr_service);
         } else if (const auto* data_ptr_domain{std::get_if<DomainPort>(&m_data)};
                    m_type == NetInfoType::Domain && data_ptr_domain && data_ptr_domain->IsValid()) {
             s << m_type << *data_ptr_domain;
@@ -240,14 +239,13 @@ class NetInfoEntry
     }
 
     template <typename Stream>
-    void Unserialize(Stream& s_)
+    void Unserialize(Stream& s)
     {
-        OverrideStream<Stream> s(&s_, /*nType=*/0, s_.GetVersion() | ADDRV2_FORMAT);
         s >> m_type;
         if (m_type == NetInfoType::Service) {
             try {
                 auto& service{m_data.emplace<CService>()};
-                s >> service;
+                s >> WithParams(CNetAddr::V2, service);
                 if (!service.IsValid()) { Clear(); } // Invalid CService, mark as invalid
             } catch (const std::ios_base::failure&) { Clear(); } // Deser failed, mark as invalid
         } else if (m_type == NetInfoType::Domain) {
@@ -327,23 +325,23 @@ class MnNetInfo final : public NetInfoInterface
     void Serialize(Stream& s) const
     {
         if (const auto service_opt{m_addr.GetAddrPort()}) {
-            s << *service_opt;
+            s << WithParams(CNetAddr::V1, *service_opt);
         } else {
-            s << CService{};
+            s << WithParams(CNetAddr::V1, CService{});
         }
     }
 
     // cppcheck-suppress functionStatic
     void Serialize(CSizeComputer& s) const
     {
-        s.seek(::GetSerializeSize(CService{}, s.GetVersion()));
+        s.seek(::GetSerializeSize(WithParams(CNetAddr::V1, CService{}), s.GetVersion()));
     }
 
     template <typename Stream>
     void Unserialize(Stream& s)
     {
         CService service;
-        s >> service;
+        s >> WithParams(CNetAddr::V1, service);
         m_addr = NetInfoEntry{service};
     }
 

src/hash.h

@@ -235,18 +235,18 @@ class CHashVerifier : public CHashWriter
 
 /** Writes data to an underlying source stream, while hashing the written data. */
 template <typename Source>
-class HashedSourceWriter : public CHashWriter
+class HashedSourceWriter : public HashWriter
 {
 private:
     Source& m_source;
 
 public:
-    explicit HashedSourceWriter(Source& source LIFETIMEBOUND) : CHashWriter{source.GetType(), source.GetVersion()}, m_source{source} {}
+    explicit HashedSourceWriter(Source& source LIFETIMEBOUND) : HashWriter{}, m_source{source} {}
 
     void write(Span<const std::byte> src)
     {
         m_source.write(src);
-        CHashWriter::write(src);
+        HashWriter::write(src);
     }
 
     template <typename T>

src/index/disktxpos.h

@@ -14,8 +14,7 @@ struct CDiskTxPos : public FlatFilePos
 
     SERIALIZE_METHODS(CDiskTxPos, obj)
     {
-        READWRITEAS(FlatFilePos, obj);
-        READWRITE(VARINT(obj.nTxOffset));
+        READWRITE(AsBase<FlatFilePos>(obj), VARINT(obj.nTxOffset));
     }
 
     CDiskTxPos(const FlatFilePos &blockIn, unsigned int nTxOffsetIn) : FlatFilePos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {

src/llmq/snapshot.h

@@ -60,7 +60,7 @@ class CQuorumSnapshot
     template <typename Stream>
     void Serialize(Stream& s) const
     {
-        const_cast<CQuorumSnapshot*>(this)->SerializationOpBase(s, CSerActionSerialize());
+        const_cast<CQuorumSnapshot*>(this)->SerializationOpBase(s, ActionSerialize());
 
         WriteCompactSize(s, activeQuorumMembers.size());
         WriteFixedBitSet(s, activeQuorumMembers, activeQuorumMembers.size());
@@ -73,7 +73,7 @@ class CQuorumSnapshot
     template <typename Stream>
     void Unserialize(Stream& s)
     {
-        SerializationOpBase(s, CSerActionUnserialize());
+        SerializationOpBase(s, ActionUnserialize());
 
         size_t cnt = ReadCompactSize(s);
         ReadFixedBitSet(s, activeQuorumMembers, cnt);
@@ -158,7 +158,7 @@ class CQuorumRotationInfo
     template <typename Stream>
     void Serialize(Stream& s) const
     {
-        const_cast<CQuorumRotationInfo*>(this)->SerializationOpBase(s, CSerActionSerialize());
+        const_cast<CQuorumRotationInfo*>(this)->SerializationOpBase(s, ActionSerialize());
 
         if (extraShare) {
             // Needed to maintain compatibility with existing on-disk format
@@ -185,7 +185,7 @@ class CQuorumRotationInfo
     template <typename Stream>
     void Unserialize(Stream& s)
     {
-        SerializationOpBase(s, CSerActionUnserialize());
+        SerializationOpBase(s, ActionUnserialize());
 
         if (extraShare) {
             CycleData val{};

src/net.cpp

@@ -213,7 +213,8 @@ static std::vector<CAddress> ConvertSeeds(const std::vector<uint8_t> &vSeedsIn)
     const auto one_week{7 * 24h};
     std::vector<CAddress> vSeedsOut;
     FastRandomContext rng;
-    CDataStream s(vSeedsIn, SER_NETWORK, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    DataStream underlying_stream{vSeedsIn};
+    ParamsStream s{CAddress::V2_NETWORK, underlying_stream};
     while (!s.eof()) {
         CService endpoint;
         s >> endpoint;