From 35f1c94672c2260a05b95277a1f03ab616cb410c Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 22 Sep 2023 13:24:24 +0530
Subject: [PATCH 01/21] refactor: wrap P2PK scriptPubKey range into Span

Co-authored-by: Konstantin Akimov <knstqq@gmail.com>
---
 src/txmempool.cpp  |  6 +++---
 src/validation.cpp | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index aae9e0d61c959..8328db1167a7d 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -487,7 +487,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-            uint160 hashBytes(Hash160(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.end()-1));
+            uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2})};
             CMempoolAddressDeltaKey key(1, hashBytes, txhash, j, 1);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
@@ -509,7 +509,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKey()) {
-            uint160 hashBytes(Hash160(out.scriptPubKey.begin()+1, out.scriptPubKey.end()-1));
+            uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
             std::pair<addressDeltaMap::iterator,bool> ret;
             CMempoolAddressDeltaKey key(1, hashBytes, txhash, k, 0);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
@@ -572,7 +572,7 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
             addressHash = uint160(std::vector<unsigned char> (prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
             addressType = 1;
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-            addressHash = Hash160(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.end()-1);
+            addressHash = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2});
             addressType = 1;
         } else {
             addressHash.SetNull();
diff --git a/src/validation.cpp b/src/validation.cpp
index 845e9ba229c13..e195e0b97067f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1726,7 +1726,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                     addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), hash, k), CAddressUnspentValue()));
 
                 } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                    uint160 hashBytes(Hash160(out.scriptPubKey.begin()+1, out.scriptPubKey.end()-1));
+                    uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
                     addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, hash, k, false), out.nValue));
                     addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, hash, k), CAddressUnspentValue()));
                 } else {
@@ -1794,7 +1794,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                         addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
 
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        uint160 hashBytes(Hash160(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.end()-1));
+                        uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2})};
                         // undo spending activity
                         addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
                         // restore unspent index
@@ -2265,7 +2265,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                         hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
                         addressType = 1;
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        hashBytes = Hash160(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.end()-1);
+                        hashBytes = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2});
                         addressType = 1;
                     } else {
                         hashBytes.SetNull();
@@ -2341,7 +2341,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                     addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
 
                 } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                    uint160 hashBytes(Hash160(out.scriptPubKey.begin()+1, out.scriptPubKey.end()-1));
+                    uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size()-2})};
                     addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
                     addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
                 } else {
@@ -4871,7 +4871,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                         hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
                         addressType = 1;
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        hashBytes = Hash160(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.end()-1);
+                        hashBytes = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2});
                         addressType = 1;
                     } else {
                         hashBytes.SetNull();
@@ -4917,7 +4917,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                         addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
 
                     } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                        uint160 hashBytes(Hash160(out.scriptPubKey.begin()+1, out.scriptPubKey.end()-1));
+                        uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size()-2})};
                         addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
                         addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
                     } else {

From 7ddf2ff59b1172208ea8e43683c7df64dc94933f Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 20 Sep 2023 16:58:43 +0530
Subject: [PATCH 02/21] refactor: remove unused Hash function variants

The three object variant was removed in dash#3276 through the backport
of bitcoin#11385, leaving behind the four, five and six variant options.
They aren't used anywhere in the codebase and aren't present in Bitcoin
Core currently, and so, have been removed.
---
 src/hash.h | 54 ------------------------------------------------------
 1 file changed, 54 deletions(-)

diff --git a/src/hash.h b/src/hash.h
index 80322a163e5da..4be5e9c72fc71 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -106,60 +106,6 @@ inline uint256 Hash(const T1 p1begin, const T1 p1end,
     return result;
 }
 
-/** Compute the 256-bit hash of the concatenation of three objects. */
-template<typename T1, typename T2, typename T3, typename T4>
-inline uint256 Hash(const T1 p1begin, const T1 p1end,
-                    const T2 p2begin, const T2 p2end,
-                    const T3 p3begin, const T3 p3end,
-                    const T4 p4begin, const T4 p4end) {
-    static const unsigned char pblank[1] = {};
-    uint256 result;
-    CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
-              .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
-              .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
-              .Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0]))
-              .Finalize((unsigned char*)&result);
-    return result;
-}
-
-/** Compute the 256-bit hash of the concatenation of three objects. */
-template<typename T1, typename T2, typename T3, typename T4, typename T5>
-inline uint256 Hash(const T1 p1begin, const T1 p1end,
-                    const T2 p2begin, const T2 p2end,
-                    const T3 p3begin, const T3 p3end,
-                    const T4 p4begin, const T4 p4end,
-                    const T5 p5begin, const T5 p5end) {
-    static const unsigned char pblank[1] = {};
-    uint256 result;
-    CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
-              .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
-              .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
-              .Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0]))
-              .Write(p5begin == p5end ? pblank : (const unsigned char*)&p5begin[0], (p5end - p5begin) * sizeof(p5begin[0]))
-              .Finalize((unsigned char*)&result);
-    return result;
-}
-
-/** Compute the 256-bit hash of the concatenation of three objects. */
-template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-inline uint256 Hash(const T1 p1begin, const T1 p1end,
-                    const T2 p2begin, const T2 p2end,
-                    const T3 p3begin, const T3 p3end,
-                    const T4 p4begin, const T4 p4end,
-                    const T5 p5begin, const T5 p5end,
-                    const T6 p6begin, const T6 p6end) {
-    static const unsigned char pblank[1] = {};
-    uint256 result;
-    CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
-              .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
-              .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
-              .Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0]))
-              .Write(p5begin == p5end ? pblank : (const unsigned char*)&p5begin[0], (p5end - p5begin) * sizeof(p5begin[0]))
-              .Write(p6begin == p6end ? pblank : (const unsigned char*)&p6begin[0], (p6end - p6begin) * sizeof(p6begin[0]))
-              .Finalize((unsigned char*)&result);
-    return result;
-}
-
 /** Compute the 160-bit hash an object. */
 template<typename T1>
 inline uint160 Hash160(const T1 pbegin, const T1 pend)

From 65ff12c303f1ca8303e608209fa101b066f6f508 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 8 Sep 2023 19:04:57 +0530
Subject: [PATCH 03/21] merge bitcoin#19326: Simplify hash.h interface using
 Spans

includes:
- 2a2182c387f607cd8284f33890bd285a81077b7f
- 77c507358bda9bd6c496f33e0f4418c0603bb08d

completion of partial merge done in dash#4164 as 56f1b2d (blocker
bitcoin#17938 was merged in dash#5246 as 00802bb)
---
 src/base58.cpp                   |  4 ++--
 src/flat-database.h              |  4 ++--
 src/hash.h                       | 35 +++++++-------------------------
 src/hdchain.cpp                  |  2 +-
 src/merkleblock.cpp              |  4 ++--
 src/net.cpp                      |  2 +-
 src/netaddress.cpp               |  2 +-
 src/pubkey.h                     |  4 ++--
 src/script/standard.cpp          |  5 ++---
 src/test/fuzz/crypto.cpp         |  2 +-
 src/test/fuzz/key.cpp            |  2 +-
 src/test/key_tests.cpp           |  8 ++++----
 src/test/merkle_tests.cpp        |  7 +++----
 src/test/serialize_tests.cpp     |  4 ++--
 src/test/util_tests.cpp          |  4 ++--
 src/util/hash_type.h             |  3 +++
 src/wallet/test/wallet_tests.cpp |  2 +-
 src/wallet/walletdb.cpp          |  8 ++++----
 18 files changed, 41 insertions(+), 61 deletions(-)

diff --git a/src/base58.cpp b/src/base58.cpp
index 36d00120664c8..b505d52583c4e 100644
--- a/src/base58.cpp
+++ b/src/base58.cpp
@@ -136,7 +136,7 @@ std::string EncodeBase58Check(Span<const unsigned char> input)
 {
     // add 4-byte hash check to the end
     std::vector<unsigned char> vch(input.begin(), input.end());
-    uint256 hash = Hash(vch.begin(), vch.end());
+    uint256 hash = Hash(vch);
     vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
     return EncodeBase58(vch);
 }
@@ -149,7 +149,7 @@ bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet, int
         return false;
     }
     // re-calculate the checksum, ensure it matches the included 4-byte checksum
-    uint256 hash = Hash(vchRet.begin(), vchRet.end() - 4);
+    uint256 hash = Hash(MakeSpan(vchRet).first(vchRet.size() - 4));
     if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {
         vchRet.clear();
         return false;
diff --git a/src/flat-database.h b/src/flat-database.h
index 405707677244c..c08c42a5e3991 100644
--- a/src/flat-database.h
+++ b/src/flat-database.h
@@ -47,7 +47,7 @@ class CFlatDB
         ssObj << strMagicMessage; // specific magic message for this type of object
         ssObj << Params().MessageStart(); // network specific magic number
         ssObj << objToSave;
-        uint256 hash = Hash(ssObj.begin(), ssObj.end());
+        uint256 hash = Hash(ssObj);
         ssObj << hash;
 
         // open output file, and associate with CAutoFile
@@ -109,7 +109,7 @@ class CFlatDB
         CDataStream ssObj(vchData, SER_DISK, CLIENT_VERSION);
 
         // verify stored checksum matches input data
-        uint256 hashTmp = Hash(ssObj.begin(), ssObj.end());
+        uint256 hashTmp = Hash(ssObj);
         if (hashIn != hashTmp)
         {
             error("%s: Checksum mismatch, data corrupted", __func__);
diff --git a/src/hash.h b/src/hash.h
index 4be5e9c72fc71..ce48d77bda5d1 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -84,52 +84,31 @@ class CHash160 {
 };
 
 /** Compute the 256-bit hash of an object. */
-template<typename T1>
-inline uint256 Hash(const T1 pbegin, const T1 pend)
+template<typename T>
+inline uint256 Hash(const T& in1)
 {
-    static const unsigned char pblank[1] = {};
     uint256 result;
-    CHash256().Write({pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])})
-              .Finalize(result);
+    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
     return result;
 }
 
 /** Compute the 256-bit hash of the concatenation of two objects. */
 template<typename T1, typename T2>
-inline uint256 Hash(const T1 p1begin, const T1 p1end,
-                    const T2 p2begin, const T2 p2end) {
-    static const unsigned char pblank[1] = {};
+inline uint256 Hash(const T1& in1, const T2& in2) {
     uint256 result;
-    CHash256().Write({p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])})
-              .Write({p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])})
-              .Finalize(result);
+    CHash256().Write(MakeUCharSpan(in1)).Write(MakeUCharSpan(in2)).Finalize(result);
     return result;
 }
 
 /** Compute the 160-bit hash an object. */
 template<typename T1>
-inline uint160 Hash160(const T1 pbegin, const T1 pend)
+inline uint160 Hash160(const T1& in1)
 {
-    static unsigned char pblank[1] = {};
     uint160 result;
-    CHash160().Write({pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])})
-              .Finalize(result);
+    CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
     return result;
 }
 
-/** Compute the 160-bit hash of a vector. */
-inline uint160 Hash160(const std::vector<unsigned char>& vch)
-{
-    return Hash160(vch.begin(), vch.end());
-}
-
-/** Compute the 160-bit hash of a vector. */
-template<unsigned int N>
-inline uint160 Hash160(const prevector<N, unsigned char>& vch)
-{
-    return Hash160(vch.begin(), vch.end());
-}
-
 /** A writer stream (for serialization) that computes a 256-bit hash. */
 class CHashWriter
 {
diff --git a/src/hdchain.cpp b/src/hdchain.cpp
index 12852f4d8e9bb..43e7b397fe1a7 100644
--- a/src/hdchain.cpp
+++ b/src/hdchain.cpp
@@ -153,7 +153,7 @@ SecureVector CHDChain::GetSeed() const
 uint256 CHDChain::GetSeedHash()
 {
     LOCK(cs);
-    return Hash(vchSeed.begin(), vchSeed.end());
+    return Hash(vchSeed);
 }
 
 void CHDChain::DeriveChildExtKey(uint32_t nAccountIndex, bool fInternal, uint32_t nChildIndex, CExtKey& extKeyRet, KeyOriginInfo& key_origin)
diff --git a/src/merkleblock.cpp b/src/merkleblock.cpp
index c55fab4773502..a53b65bea238f 100644
--- a/src/merkleblock.cpp
+++ b/src/merkleblock.cpp
@@ -84,7 +84,7 @@ uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::ve
         else
             right = left;
         // combine subhashes
-        return Hash(left.begin(), left.end(), right.begin(), right.end());
+        return Hash(left, right);
     }
 }
 
@@ -140,7 +140,7 @@ uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, uns
             right = left;
         }
         // and combine them before returning
-        return Hash(left.begin(), left.end(), right.begin(), right.end());
+        return Hash(left, right);
     }
 }
 
diff --git a/src/net.cpp b/src/net.cpp
index 5698ad69779cf..65f63fc339ef1 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -850,7 +850,7 @@ std::optional<CNetMessage> V1TransportDeserializer::GetMessage(int64_t time, uin
 
 void V1TransportSerializer::prepareForTransport(CSerializedNetMsg& msg, std::vector<unsigned char>& header) {
     // create dbl-sha256 checksum
-    uint256 hash = Hash(msg.data.begin(), msg.data.end());
+    uint256 hash = Hash(msg.data);
 
     // create header
     CMessageHeader hdr(Params().MessageStart(), msg.command.c_str(), msg.data.size());
diff --git a/src/netaddress.cpp b/src/netaddress.cpp
index 5dbd3b544f5ba..378da0627254b 100644
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -830,7 +830,7 @@ std::vector<unsigned char> CNetAddr::GetAddrBytes() const
 
 uint64_t CNetAddr::GetHash() const
 {
-    uint256 hash = Hash(m_addr.begin(), m_addr.end());
+    uint256 hash = Hash(m_addr);
     uint64_t nRet;
     memcpy(&nRet, &hash, sizeof(nRet));
     return nRet;
diff --git a/src/pubkey.h b/src/pubkey.h
index 9b633972677c0..193b4667ab294 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -157,13 +157,13 @@ class CPubKey
     //! Get the KeyID of this public key (hash of its serialization)
     CKeyID GetID() const
     {
-        return CKeyID(Hash160(vch, vch + size()));
+        return CKeyID(Hash160(MakeSpan(vch).first(size())));
     }
 
     //! Get the 256-bit hash of this public key.
     uint256 GetHash() const
     {
-        return Hash(vch, vch + size());
+        return Hash(MakeSpan(vch).first(size()));
     }
 
     /*
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 3f7db837d0a49..3cb5bb4cdab4e 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -13,10 +13,10 @@ typedef std::vector<unsigned char> valtype;
 bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;
 unsigned nMaxDatacarrierBytes = MAX_OP_RETURN_RELAY;
 
-CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in.begin(), in.end())) {}
+CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
 CScriptID::CScriptID(const ScriptHash& in) : BaseHash(static_cast<uint160>(in)) {}
 
-ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in.begin(), in.end())) {}
+ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
 ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
 
 PKHash::PKHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
@@ -242,7 +242,6 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
     return script;
 }
 
-
 bool IsValidDestination(const CTxDestination& dest) {
     return dest.index() != 0;
 }
diff --git a/src/test/fuzz/crypto.cpp b/src/test/fuzz/crypto.cpp
index f482b516322ef..40bb2208f2a5d 100644
--- a/src/test/fuzz/crypto.cpp
+++ b/src/test/fuzz/crypto.cpp
@@ -62,8 +62,8 @@ FUZZ_TARGET(crypto)
                 (void)sha512.Write(data.data(), data.size());
                 (void)sip_hasher.Write(data.data(), data.size());
 
+                (void)Hash(data);
                 (void)Hash160(data);
-                (void)Hash160(data.begin(), data.end());
                 (void)sha512.Size();
             },
             [&] {
diff --git a/src/test/fuzz/key.cpp b/src/test/fuzz/key.cpp
index 1c8cfed65e677..686298b80352b 100644
--- a/src/test/fuzz/key.cpp
+++ b/src/test/fuzz/key.cpp
@@ -81,7 +81,7 @@ FUZZ_TARGET_INIT(key, initialize_key)
         assert(negated_key == key);
     }
 
-    const uint256 random_uint256 = Hash(buffer.begin(), buffer.end());
+    const uint256 random_uint256 = Hash(buffer);
 
     {
         CKey child_key;
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index 99ea119e30b3b..dcdd0928dfba9 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -77,7 +77,7 @@ BOOST_AUTO_TEST_CASE(key_test1)
     for (int n=0; n<16; n++)
     {
         std::string strMsg = strprintf("Very secret message %i: 11", n);
-        uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
+        uint256 hashMsg = Hash(strMsg);
 
         // normal signatures
 
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(key_test1)
 
     std::vector<unsigned char> detsig, detsigc;
     std::string strMsg = "Very deterministic message";
-    uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
+    uint256 hashMsg = Hash(strMsg);
     BOOST_CHECK(key1.Sign(hashMsg, detsig));
     BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
@@ -158,7 +158,7 @@ BOOST_AUTO_TEST_CASE(key_signature_tests)
     // When entropy is specified, we should see at least one high R signature within 20 signatures
     CKey key = DecodeSecret(strSecret1);
     std::string msg = "A message to be signed";
-    uint256 msg_hash = Hash(msg.begin(), msg.end());
+    uint256 msg_hash = Hash(msg);
     std::vector<unsigned char> sig;
     bool found = false;
 
@@ -179,7 +179,7 @@ BOOST_AUTO_TEST_CASE(key_signature_tests)
     for (int i = 0; i < 256; ++i) {
         sig.clear();
         std::string msg = "A message to be signed" + ToString(i);
-        msg_hash = Hash(msg.begin(), msg.end());
+        msg_hash = Hash(msg);
         BOOST_CHECK(key.Sign(msg_hash, sig));
         found = sig[3] == 0x20;
         BOOST_CHECK(sig.size() <= 70);
diff --git a/src/test/merkle_tests.cpp b/src/test/merkle_tests.cpp
index 1510a8697a6c0..69fff2835d9cc 100644
--- a/src/test/merkle_tests.cpp
+++ b/src/test/merkle_tests.cpp
@@ -13,9 +13,9 @@ static uint256 ComputeMerkleRootFromBranch(const uint256& leaf, const std::vecto
     uint256 hash = leaf;
     for (std::vector<uint256>::const_iterator it = vMerkleBranch.begin(); it != vMerkleBranch.end(); ++it) {
         if (nIndex & 1) {
-            hash = Hash(it->begin(), it->end(), hash.begin(), hash.end());
+            hash = Hash(*it, hash);
         } else {
-            hash = Hash(hash.begin(), hash.end(), it->begin(), it->end());
+            hash = Hash(hash, *it);
         }
         nIndex >>= 1;
     }
@@ -144,8 +144,7 @@ static uint256 BlockBuildMerkleTree(const CBlock& block, bool* fMutated, std::ve
                 // Two identical hashes at the end of the list at a particular level.
                 mutated = true;
             }
-            vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(), vMerkleTree[j+i].end(),
-                                       vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));
+            vMerkleTree.push_back(Hash(vMerkleTree[j+i], vMerkleTree[j+i2]));
         }
         j += nSize;
     }
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index 9690755ff33f7..4dcfff4cc83c4 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(floats)
     for (int i = 0; i < 1000; i++) {
         ss << float(i);
     }
-    BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c"));
+    BOOST_CHECK(Hash(ss) == uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c"));
 
     // decode
     for (int i = 0; i < 1000; i++) {
@@ -162,7 +162,7 @@ BOOST_AUTO_TEST_CASE(doubles)
     for (int i = 0; i < 1000; i++) {
         ss << double(i);
     }
-    BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
+    BOOST_CHECK(Hash(ss) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
 
     // decode
     for (int i = 0; i < 1000; i++) {
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index d06bdec5c06a6..4095e2a7396b1 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -2576,8 +2576,8 @@ BOOST_AUTO_TEST_CASE(message_hash)
         std::string(1, (char)unsigned_tx.length()) +
         unsigned_tx;
 
-    const uint256 signature_hash = Hash(unsigned_tx.begin(), unsigned_tx.end());
-    const uint256 message_hash1 = Hash(prefixed_message.begin(), prefixed_message.end());
+    const uint256 signature_hash = Hash(unsigned_tx);
+    const uint256 message_hash1 = Hash(prefixed_message);
     const uint256 message_hash2 = MessageHash(unsigned_tx);
 
     BOOST_CHECK_EQUAL(message_hash1, message_hash2);
diff --git a/src/util/hash_type.h b/src/util/hash_type.h
index 96771546dc0fd..6113644393626 100644
--- a/src/util/hash_type.h
+++ b/src/util/hash_type.h
@@ -64,6 +64,9 @@ class BaseHash
     {
         return m_hash.size();
     }
+
+    unsigned char* data() { return m_hash.data(); }
+    const unsigned char* data() const { return m_hash.data(); }
 };
 
 #endif // BITCOIN_UTIL_HASH_TYPE_H
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 98ad52d252c2c..dc72bee749f1f 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -1323,7 +1323,7 @@ static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
     CPubKey pubkey = key.GetPubKey();
 
     // Generate pubkey hash
-    uint160 key_hash(Hash160(pubkey.begin(), pubkey.end()));
+    uint160 key_hash(Hash160(pubkey));
 
     // Create inner-script to enter into keystore. Key hash can't be 0...
     CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 82ee674140100..9ea4bba0cc532 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -113,7 +113,7 @@ bool WalletBatch::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey,
     vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
 
-    return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
+    return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey)), false);
 }
 
 bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
@@ -125,7 +125,7 @@ bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
     }
 
     // Compute a checksum of the encrypted key
-    uint256 checksum = Hash(vchCryptedSecret.begin(), vchCryptedSecret.end());
+    uint256 checksum = Hash(vchCryptedSecret);
 
     const auto key = std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey);
     if (!WriteIC(key, std::make_pair(vchCryptedSecret, checksum), false)) {
@@ -339,7 +339,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
                 vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
                 vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
 
-                if (Hash(vchKey.begin(), vchKey.end()) != hash)
+                if (Hash(vchKey) != hash)
                 {
                     strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
                     return false;
@@ -388,7 +388,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
             if (!ssValue.eof()) {
                 uint256 checksum;
                 ssValue >> checksum;
-                if ((checksum_valid = Hash(vchPrivKey.begin(), vchPrivKey.end()) != checksum)) {
+                if ((checksum_valid = Hash(vchPrivKey) != checksum)) {
                     strErr = "Error reading wallet database: Crypted key corrupt";
                     return false;
                 }

From dba0dc950153aa74da2bb14330dc4a03aaca0dcd Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 11 Sep 2023 00:53:19 +0530
Subject: [PATCH 04/21] merge bitcoin#20464: Treat CDataStream bytes as uint8_t

---
 src/bench/prevector.cpp                |  2 +-
 src/dbwrapper.h                        | 29 +++++----
 src/llmq/dkgsessionhandler.cpp         |  2 +-
 src/psbt.cpp                           |  2 +-
 src/qt/recentrequeststablemodel.cpp    |  2 +-
 src/qt/walletmodel.cpp                 |  2 +-
 src/rpc/rawtransaction.cpp             | 10 +--
 src/streams.h                          | 90 ++++++++------------------
 src/support/allocators/zeroafterfree.h |  4 +-
 src/test/bloom_tests.cpp               | 24 ++-----
 src/test/fuzz/util.h                   |  2 +-
 src/test/serialize_tests.cpp           | 11 +---
 src/test/streams_tests.cpp             |  2 +-
 src/wallet/bdb.cpp                     |  4 +-
 14 files changed, 64 insertions(+), 122 deletions(-)

diff --git a/src/bench/prevector.cpp b/src/bench/prevector.cpp
index 5075312fe9ae1..36a16ef019c80 100644
--- a/src/bench/prevector.cpp
+++ b/src/bench/prevector.cpp
@@ -79,7 +79,7 @@ static void PrevectorDeserialize(benchmark::Bench& bench)
         for (auto x = 0; x < 1000; ++x) {
             s0 >> t1;
         }
-        s0.Init(SER_NETWORK, 0);
+        s0.Rewind();
     });
 }
 
diff --git a/src/dbwrapper.h b/src/dbwrapper.h
index ff618fcfe06e1..5a86aeedbccf4 100644
--- a/src/dbwrapper.h
+++ b/src/dbwrapper.h
@@ -8,9 +8,10 @@
 #include <clientversion.h>
 #include <fs.h>
 #include <serialize.h>
+#include <span.h>
 #include <streams.h>
-#include <util/system.h>
 #include <util/strencodings.h>
+#include <util/system.h>
 
 #include <typeindex>
 
@@ -82,12 +83,12 @@ class CDBBatch
     template <typename V>
     void Write(const CDataStream& _ssKey, const V& value)
     {
-        leveldb::Slice slKey(_ssKey.data(), _ssKey.size());
+        leveldb::Slice slKey((const char*)_ssKey.data(), _ssKey.size());
 
         ssValue.reserve(DBWRAPPER_PREALLOC_VALUE_SIZE);
         ssValue << value;
         ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
-        leveldb::Slice slValue(ssValue.data(), ssValue.size());
+        leveldb::Slice slValue((const char*)ssValue.data(), ssValue.size());
 
         batch.Put(slKey, slValue);
         // - varint: key length (1 byte up to 127B, 2 bytes up to 16383B, ...)
@@ -109,7 +110,7 @@ class CDBBatch
     }
 
     void Erase(const CDataStream& _ssKey) {
-        leveldb::Slice slKey(_ssKey.data(), _ssKey.size());
+        leveldb::Slice slKey((const char*)_ssKey.data(), _ssKey.size());
 
         batch.Delete(slKey);
         // - byte: header
@@ -150,7 +151,7 @@ class CDBIterator
     }
 
     void Seek(const CDataStream& ssKey) {
-        leveldb::Slice slKey(ssKey.data(), ssKey.size());
+        leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
         piter->Seek(slKey);
     }
 
@@ -168,7 +169,7 @@ class CDBIterator
 
     CDataStream GetKey() {
         leveldb::Slice slKey = piter->key();
-        return CDataStream(slKey.data(), slKey.data() + slKey.size(), SER_DISK, CLIENT_VERSION);
+        return CDataStream(MakeUCharSpan(slKey), SER_DISK, CLIENT_VERSION);
     }
 
     unsigned int GetKeySize() {
@@ -178,7 +179,7 @@ class CDBIterator
     template<typename V> bool GetValue(V& value) {
         leveldb::Slice slValue = piter->value();
         try {
-            CDataStream ssValue(slValue.data(), slValue.data() + slValue.size(), SER_DISK, CLIENT_VERSION);
+            CDataStream ssValue(MakeUCharSpan(slValue), SER_DISK, CLIENT_VERSION);
             ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
             ssValue >> value;
         } catch (const std::exception&) {
@@ -258,7 +259,7 @@ class CDBWrapper
 
     bool ReadDataStream(const CDataStream& ssKey, CDataStream& ssValue) const
     {
-        leveldb::Slice slKey(ssKey.data(), ssKey.size());
+        leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
 
         std::string strValue;
         leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
@@ -268,7 +269,7 @@ class CDBWrapper
             LogPrintf("LevelDB read failure: %s\n", status.ToString());
             dbwrapper_private::HandleError(status);
         }
-        CDataStream ssValueTmp(strValue.data(), strValue.data() + strValue.size(), SER_DISK, CLIENT_VERSION);
+        CDataStream ssValueTmp(MakeUCharSpan(strValue), SER_DISK, CLIENT_VERSION);
         ssValueTmp.Xor(obfuscate_key);
         ssValue = std::move(ssValueTmp);
         return true;
@@ -318,7 +319,7 @@ class CDBWrapper
 
     bool Exists(const CDataStream& key) const
     {
-        leveldb::Slice slKey(key.data(), key.size());
+        leveldb::Slice slKey((const char*)key.data(), key.size());
 
         std::string strValue;
         leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
@@ -362,8 +363,8 @@ class CDBWrapper
         ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
         ssKey1 << key_begin;
         ssKey2 << key_end;
-        leveldb::Slice slKey1(ssKey1.data(), ssKey1.size());
-        leveldb::Slice slKey2(ssKey2.data(), ssKey2.size());
+        leveldb::Slice slKey1((const char*)ssKey1.data(), ssKey1.size());
+        leveldb::Slice slKey2((const char*)ssKey2.data(), ssKey2.size());
         uint64_t size = 0;
         leveldb::Range range(slKey1, slKey2);
         pdb->GetApproximateSizes(&range, 1, &size);
@@ -381,8 +382,8 @@ class CDBWrapper
         ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
         ssKey1 << key_begin;
         ssKey2 << key_end;
-        leveldb::Slice slKey1(ssKey1.data(), ssKey1.size());
-        leveldb::Slice slKey2(ssKey2.data(), ssKey2.size());
+        leveldb::Slice slKey1((const char*)ssKey1.data(), ssKey1.size());
+        leveldb::Slice slKey2((const char*)ssKey2.data(), ssKey2.size());
         pdb->CompactRange(&slKey1, &slKey2);
     }
 
diff --git a/src/llmq/dkgsessionhandler.cpp b/src/llmq/dkgsessionhandler.cpp
index b5f515e13f1bf..4f3ba6d65dbb9 100644
--- a/src/llmq/dkgsessionhandler.cpp
+++ b/src/llmq/dkgsessionhandler.cpp
@@ -51,7 +51,7 @@ void CDKGPendingMessages::PushPendingMessage(NodeId from, CDataStream& vRecv)
     auto pm = std::make_shared<CDataStream>(std::move(vRecv));
 
     CHashWriter hw(SER_GETHASH, 0);
-    hw.write(pm->data(), pm->size());
+    hw.write(reinterpret_cast<const char*>(pm->data()), pm->size());
     uint256 hash = hw.GetHash();
 
     if (from != -1) {
diff --git a/src/psbt.cpp b/src/psbt.cpp
index 3c7532c5ce0a9..c5eafb675d513 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -461,7 +461,7 @@ bool DecodeBase64PSBT(PartiallySignedTransaction& psbt, const std::string& base6
 
 bool DecodeRawPSBT(PartiallySignedTransaction& psbt, const std::string& tx_data, std::string& error)
 {
-    CDataStream ss_data(tx_data.data(), tx_data.data() + tx_data.size(), SER_NETWORK, PROTOCOL_VERSION);
+    CDataStream ss_data(MakeUCharSpan(tx_data), SER_NETWORK, PROTOCOL_VERSION);
     try {
         ss_data >> psbt;
         if (!ss_data.empty()) {
diff --git a/src/qt/recentrequeststablemodel.cpp b/src/qt/recentrequeststablemodel.cpp
index 635d14d935fe3..d12c31caa1921 100644
--- a/src/qt/recentrequeststablemodel.cpp
+++ b/src/qt/recentrequeststablemodel.cpp
@@ -181,7 +181,7 @@ void RecentRequestsTableModel::addNewRequest(const SendCoinsRecipient &recipient
 // called from ctor when loading from wallet
 void RecentRequestsTableModel::addNewRequest(const std::string &recipient)
 {
-    std::vector<char> data(recipient.begin(), recipient.end());
+    std::vector<uint8_t> data(recipient.begin(), recipient.end());
     CDataStream ss(data, SER_DISK, CLIENT_VERSION);
 
     RecentRequestEntry entry;
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index 8a27a6719dd99..da0ebe9a4b7a6 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -288,7 +288,7 @@ WalletModel::SendCoinsReturn WalletModel::sendCoins(WalletModelTransaction &tran
 
         CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
         ssTx << *newTx;
-        transaction_array.append(ssTx.data(), ssTx.size());
+        transaction_array.append((const char*)ssTx.data(), ssTx.size());
     }
 
     // Add addresses / update labels that we've sent to the address book,
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 15332e71d49a5..bcda6799c515d 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1306,7 +1306,7 @@ UniValue combinepsbt(const JSONRPCRequest& request)
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
-    return EncodeBase64(ssTx.str());
+    return EncodeBase64(ssTx);
 }
 
 UniValue finalizepsbt(const JSONRPCRequest& request)
@@ -1434,7 +1434,7 @@ UniValue createpsbt(const JSONRPCRequest& request)
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
-    return EncodeBase64(ssTx.str());
+    return EncodeBase64(ssTx);
 }
 
 UniValue converttopsbt(const JSONRPCRequest& request)
@@ -1489,7 +1489,7 @@ UniValue converttopsbt(const JSONRPCRequest& request)
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
-    return EncodeBase64(ssTx.str());
+    return EncodeBase64(ssTx);
 }
 
 UniValue utxoupdatepsbt(const JSONRPCRequest& request)
@@ -1573,7 +1573,7 @@ UniValue utxoupdatepsbt(const JSONRPCRequest& request)
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
-    return EncodeBase64(ssTx.str());
+    return EncodeBase64(ssTx);
 }
 
 UniValue joinpsbts(const JSONRPCRequest& request)
@@ -1644,7 +1644,7 @@ UniValue joinpsbts(const JSONRPCRequest& request)
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
-    return EncodeBase64(ssTx.str());
+    return EncodeBase64(ssTx);
 }
 
 UniValue analyzepsbt(const JSONRPCRequest& request)
diff --git a/src/streams.h b/src/streams.h
index 7faf7e43d3f00..4df194db2d0f6 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -6,17 +6,19 @@
 #ifndef BITCOIN_STREAMS_H
 #define BITCOIN_STREAMS_H
 
-#include <support/allocators/zeroafterfree.h>
 #include <serialize.h>
+#include <span.h>
+#include <support/allocators/zeroafterfree.h>
 
 #include <algorithm>
 #include <assert.h>
 #include <ios>
 #include <limits>
+#include <optional>
 #include <stdint.h>
 #include <stdio.h>
-#include <string>
 #include <string.h>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -206,14 +208,14 @@ class VectorReader
 class CDataStream
 {
 protected:
-    typedef CSerializeData vector_type;
+    using vector_type = SerializeData;
     vector_type vch;
-    unsigned int nReadPos;
+    unsigned int nReadPos{0};
 
     int nType;
     int nVersion;
-public:
 
+public:
     typedef vector_type::allocator_type   allocator_type;
     typedef vector_type::size_type        size_type;
     typedef vector_type::difference_type  difference_type;
@@ -225,62 +227,22 @@ class CDataStream
     typedef vector_type::reverse_iterator reverse_iterator;
 
     explicit CDataStream(int nTypeIn, int nVersionIn)
-    {
-        Init(nTypeIn, nVersionIn);
-    }
-
-    CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn, int nVersionIn) : vch(pbegin, pend)
-    {
-        Init(nTypeIn, nVersionIn);
-    }
-
-    CDataStream(const char* pbegin, const char* pend, int nTypeIn, int nVersionIn) : vch(pbegin, pend)
-    {
-        Init(nTypeIn, nVersionIn);
-    }
-
-    CDataStream(const vector_type& vchIn, int nTypeIn, int nVersionIn) : vch(vchIn.begin(), vchIn.end())
-    {
-        Init(nTypeIn, nVersionIn);
-    }
-
-    CDataStream(const std::vector<char>& vchIn, int nTypeIn, int nVersionIn) : vch(vchIn.begin(), vchIn.end())
-    {
-        Init(nTypeIn, nVersionIn);
-    }
+        : nType{nTypeIn},
+          nVersion{nVersionIn} {}
 
-    CDataStream(const std::vector<unsigned char>& vchIn, int nTypeIn, int nVersionIn) : vch(vchIn.begin(), vchIn.end())
-    {
-        Init(nTypeIn, nVersionIn);
-    }
+    explicit CDataStream(Span<const uint8_t> sp, int nTypeIn, int nVersionIn)
+        : vch(sp.data(), sp.data() + sp.size()),
+          nType{nTypeIn},
+          nVersion{nVersionIn} {}
 
     template <typename... Args>
     CDataStream(int nTypeIn, int nVersionIn, Args&&... args)
+        : nType{nTypeIn},
+          nVersion{nVersionIn}
     {
-        Init(nTypeIn, nVersionIn);
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
 
-    void Init(int nTypeIn, int nVersionIn)
-    {
-        nReadPos = 0;
-        nType = nTypeIn;
-        nVersion = nVersionIn;
-    }
-
-    CDataStream& operator+=(const CDataStream& b)
-    {
-        vch.insert(vch.end(), b.begin(), b.end());
-        return *this;
-    }
-
-    friend CDataStream operator+(const CDataStream& a, const CDataStream& b)
-    {
-        CDataStream ret = a;
-        ret += b;
-        return (ret);
-    }
-
     std::string str() const
     {
         return (std::string(begin(), end()));
@@ -301,12 +263,12 @@ class CDataStream
     const_reference operator[](size_type pos) const  { return vch[pos + nReadPos]; }
     reference operator[](size_type pos)              { return vch[pos + nReadPos]; }
     void clear()                                     { vch.clear(); nReadPos = 0; }
-    iterator insert(iterator it, const char x=char()) { return vch.insert(it, x); }
-    void insert(iterator it, size_type n, const char x) { vch.insert(it, n, x); }
+    iterator insert(iterator it, const uint8_t x) { return vch.insert(it, x); }
+    void insert(iterator it, size_type n, const uint8_t x) { vch.insert(it, n, x); }
     value_type* data()                               { return vch.data() + nReadPos; }
     const value_type* data() const                   { return vch.data() + nReadPos; }
 
-    void insert(iterator it, std::vector<char>::const_iterator first, std::vector<char>::const_iterator last)
+    void insert(iterator it, std::vector<uint8_t>::const_iterator first, std::vector<uint8_t>::const_iterator last)
     {
         if (last == first) return;
         assert(last - first > 0);
@@ -377,12 +339,17 @@ class CDataStream
         nReadPos = 0;
     }
 
-    bool Rewind(size_type n)
+    bool Rewind(std::optional<size_type> n = std::nullopt)
     {
+        // Total rewind if no size is passed
+        if (!n) {
+            nReadPos = 0;
+            return true;
+        }
         // Rewind by n characters if the buffer hasn't been compacted yet
-        if (n > nReadPos)
+        if (*n > nReadPos)
             return false;
-        nReadPos -= n;
+        nReadPos -= *n;
         return true;
     }
 
@@ -466,11 +433,6 @@ class CDataStream
         return (*this);
     }
 
-    void GetAndClear(CSerializeData &d) {
-        d.insert(d.end(), begin(), end());
-        clear();
-    }
-
     /**
      * XOR the contents of this stream with a certain key.
      *
diff --git a/src/support/allocators/zeroafterfree.h b/src/support/allocators/zeroafterfree.h
index 6bcf192b5f88c..623a936fe2a42 100644
--- a/src/support/allocators/zeroafterfree.h
+++ b/src/support/allocators/zeroafterfree.h
@@ -40,7 +40,7 @@ struct zero_after_free_allocator : public std::allocator<T> {
     }
 };
 
-// Byte-vector that clears its contents before deletion.
-typedef std::vector<char, zero_after_free_allocator<char> > CSerializeData;
+/** Byte-vector that clears its contents before deletion. */
+using SerializeData = std::vector<uint8_t, zero_after_free_allocator<uint8_t>>;
 
 #endif // BITCOIN_SUPPORT_ALLOCATORS_ZEROAFTERFREE_H
diff --git a/src/test/bloom_tests.cpp b/src/test/bloom_tests.cpp
index 41158d992d45e..d15632893dc65 100644
--- a/src/test/bloom_tests.cpp
+++ b/src/test/bloom_tests.cpp
@@ -40,11 +40,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;
 
-    std::vector<unsigned char> vch = ParseHex("03614e9b050000000000000001");
-    std::vector<char> expected(vch.size());
-
-    for (unsigned int i = 0; i < vch.size(); i++)
-        expected[i] = (char)vch[i];
+    std::vector<uint8_t> expected = ParseHex("03614e9b050000000000000001");
 
     BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(), expected.begin(), expected.end());
 
@@ -70,11 +66,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;
 
-    std::vector<unsigned char> vch = ParseHex("03ce4299050000000100008001");
-    std::vector<char> expected(vch.size());
-
-    for (unsigned int i = 0; i < vch.size(); i++)
-        expected[i] = (char)vch[i];
+    std::vector<uint8_t> expected = ParseHex("03ce4299050000000100008001");
 
     BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(), expected.begin(), expected.end());
 }
@@ -94,11 +86,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;
 
-    std::vector<unsigned char> vch = ParseHex("038fc16b080000000000000001");
-    std::vector<char> expected(vch.size());
-
-    for (unsigned int i = 0; i < vch.size(); i++)
-        expected[i] = (char)vch[i];
+    std::vector<unsigned char> expected = ParseHex("038fc16b080000000000000001");
 
     BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(), expected.begin(), expected.end());
 }
@@ -454,11 +442,7 @@ BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize)
     CDataStream merkleStream(SER_NETWORK, PROTOCOL_VERSION);
     merkleStream << merkleBlock;
 
-    std::vector<unsigned char> vch = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");
-    std::vector<char> expected(vch.size());
-
-    for (unsigned int i = 0; i < vch.size(); i++)
-        expected[i] = (char)vch[i];
+    std::vector<uint8_t> expected = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");
 
     BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), merkleStream.begin(), merkleStream.end());
 }
diff --git a/src/test/fuzz/util.h b/src/test/fuzz/util.h
index bc0d48c24dbb4..30a3580e3913c 100644
--- a/src/test/fuzz/util.h
+++ b/src/test/fuzz/util.h
@@ -64,7 +64,7 @@ void CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
 
 [[ nodiscard ]] inline CDataStream ConsumeDataStream(FuzzedDataProvider& fuzzed_data_provider, const size_t max_length = 4096) noexcept
 {
-    return {ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length), SER_NETWORK, INIT_PROTO_VERSION};
+    return CDataStream{ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length), SER_NETWORK, INIT_PROTO_VERSION};
 }
 
 [[ nodiscard ]] inline std::vector<std::string> ConsumeRandomLengthStringVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_vector_size = 16, const size_t max_string_length = 16) noexcept
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index 4dcfff4cc83c4..f1332d4a659a1 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -320,7 +320,7 @@ BOOST_AUTO_TEST_CASE(insert_delete)
 
     ss.insert(ss.end(), c);
     BOOST_CHECK_EQUAL(ss.size(), 6U);
-    BOOST_CHECK_EQUAL(ss[4], (char)0xff);
+    BOOST_CHECK_EQUAL(ss[4], 0xff);
     BOOST_CHECK_EQUAL(ss[5], c);
 
     ss.insert(ss.begin()+2, c);
@@ -334,19 +334,14 @@ BOOST_AUTO_TEST_CASE(insert_delete)
 
     ss.erase(ss.begin()+ss.size()-1);
     BOOST_CHECK_EQUAL(ss.size(), 5U);
-    BOOST_CHECK_EQUAL(ss[4], (char)0xff);
+    BOOST_CHECK_EQUAL(ss[4], 0xff);
 
     ss.erase(ss.begin()+1);
     BOOST_CHECK_EQUAL(ss.size(), 4U);
     BOOST_CHECK_EQUAL(ss[0], 0);
     BOOST_CHECK_EQUAL(ss[1], 1);
     BOOST_CHECK_EQUAL(ss[2], 2);
-    BOOST_CHECK_EQUAL(ss[3], (char)0xff);
-
-    // Make sure GetAndClear does the right thing:
-    CSerializeData d;
-    ss.GetAndClear(d);
-    BOOST_CHECK_EQUAL(ss.size(), 0U);
+    BOOST_CHECK_EQUAL(ss[3], 0xff);
 }
 
 // Change struct size and check if it can be deserialized
diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
index b0b8f9853d7c5..ba2d879bb716d 100644
--- a/src/test/streams_tests.cpp
+++ b/src/test/streams_tests.cpp
@@ -160,7 +160,7 @@ BOOST_AUTO_TEST_CASE(bitstream_reader_writer)
 
 BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
 {
-    std::vector<char> in;
+    std::vector<uint8_t> in;
     std::vector<char> expected_xor;
     std::vector<unsigned char> key;
     CDataStream ds(in, 0, 0);
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index a8d35f6e36364..640c99e564f9b 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -488,9 +488,9 @@ bool BerkeleyDatabase::Rewrite(const char* pszSkip)
                                 break;
                             }
                             if (pszSkip &&
-                                strncmp(ssKey.data(), pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0)
+                                strncmp((const char*)ssKey.data(), pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0)
                                 continue;
-                            if (strncmp(ssKey.data(), "\x07version", 8) == 0) {
+                            if (strncmp((const char*)ssKey.data(), "\x07version", 8) == 0) {
                                 // Update version:
                                 ssValue.clear();
                                 ssValue << CLIENT_VERSION;

From bb8bd9a94d76a70117b5a8623c03fe79dc92ce8f Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 4 Nov 2021 09:17:14 +0100
Subject: [PATCH 05/21] merge bitcoin#23451: Add std::byte helpers

---
 src/pubkey.h               |  6 ++----
 src/span.h                 | 25 +++++++++++++++++++++++++
 src/streams.h              | 12 ++++++------
 src/test/base64_tests.cpp  | 10 ++++++++++
 src/test/streams_tests.cpp |  6 +++---
 src/test/util_tests.cpp    | 23 ++++++++++++++++++-----
 src/util/strencodings.cpp  |  5 -----
 src/util/strencodings.h    |  5 +++--
 8 files changed, 67 insertions(+), 25 deletions(-)

diff --git a/src/pubkey.h b/src/pubkey.h
index 193b4667ab294..c2aa8517259f1 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -139,7 +139,7 @@ class CPubKey
     template <typename Stream>
     void Unserialize(Stream& s)
     {
-        unsigned int len = ::ReadCompactSize(s);
+        const unsigned int len(::ReadCompactSize(s));
         if (len <= SIZE) {
             s.read((char*)vch, len);
             if (len != size()) {
@@ -147,9 +147,7 @@ class CPubKey
             }
         } else {
             // invalid pubkey, skip available data
-            char dummy;
-            while (len--)
-                s.read(&dummy, 1);
+            s.ignore(len);
             Invalidate();
         }
     }
diff --git a/src/span.h b/src/span.h
index de88fa08c59b6..3d96269768afd 100644
--- a/src/span.h
+++ b/src/span.h
@@ -180,6 +180,7 @@ class Span
         return m_data[m_size - 1];
     }
     constexpr std::size_t size() const noexcept { return m_size; }
+    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
     constexpr bool empty() const noexcept { return size() == 0; }
     CONSTEXPR_IF_NOT_DEBUG C& operator[](std::size_t pos) const noexcept
     {
@@ -236,11 +237,35 @@ T& SpanPopBack(Span<T>& span)
     return back;
 }
 
+// From C++20 as_bytes and as_writeable_bytes
+template <typename T>
+Span<const std::byte> AsBytes(Span<T> s) noexcept
+{
+    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
+}
+template <typename T>
+Span<std::byte> AsWritableBytes(Span<T> s) noexcept
+{
+    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
+}
+
+template <typename V>
+Span<const std::byte> MakeByteSpan(V&& v) noexcept
+{
+    return AsBytes(MakeSpan(std::forward<V>(v)));
+}
+template <typename V>
+Span<std::byte> MakeWritableByteSpan(V&& v) noexcept
+{
+    return AsWritableBytes(MakeSpan(std::forward<V>(v)));
+}
+
 // Helper functions to safely cast to unsigned char pointers.
 inline unsigned char* UCharCast(char* c) { return (unsigned char*)c; }
 inline unsigned char* UCharCast(unsigned char* c) { return c; }
 inline const unsigned char* UCharCast(const char* c) { return (unsigned char*)c; }
 inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
+inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
 
 // Helper function to safely convert a Span to a Span<[const] unsigned char>.
 template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
diff --git a/src/streams.h b/src/streams.h
index 4df194db2d0f6..7ddf405049118 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -230,7 +230,7 @@ class CDataStream
         : nType{nTypeIn},
           nVersion{nVersionIn} {}
 
-    explicit CDataStream(Span<const uint8_t> sp, int nTypeIn, int nVersionIn)
+    explicit CDataStream(Span<const value_type> sp, int nTypeIn, int nVersionIn)
         : vch(sp.data(), sp.data() + sp.size()),
           nType{nTypeIn},
           nVersion{nVersionIn} {}
@@ -258,17 +258,17 @@ class CDataStream
     iterator end()                                   { return vch.end(); }
     size_type size() const                           { return vch.size() - nReadPos; }
     bool empty() const                               { return vch.size() == nReadPos; }
-    void resize(size_type n, value_type c=0)         { vch.resize(n + nReadPos, c); }
+    void resize(size_type n, value_type c = value_type{}) { vch.resize(n + nReadPos, c); }
     void reserve(size_type n)                        { vch.reserve(n + nReadPos); }
     const_reference operator[](size_type pos) const  { return vch[pos + nReadPos]; }
     reference operator[](size_type pos)              { return vch[pos + nReadPos]; }
     void clear()                                     { vch.clear(); nReadPos = 0; }
-    iterator insert(iterator it, const uint8_t x) { return vch.insert(it, x); }
-    void insert(iterator it, size_type n, const uint8_t x) { vch.insert(it, n, x); }
+    iterator insert(iterator it, const value_type x) { return vch.insert(it, x); }
+    void insert(iterator it, size_type n, const value_type x) { vch.insert(it, n, x); }
     value_type* data()                               { return vch.data() + nReadPos; }
     const value_type* data() const                   { return vch.data() + nReadPos; }
 
-    void insert(iterator it, std::vector<uint8_t>::const_iterator first, std::vector<uint8_t>::const_iterator last)
+    void insert(iterator it, std::vector<value_type>::const_iterator first, std::vector<value_type>::const_iterator last)
     {
         if (last == first) return;
         assert(last - first > 0);
@@ -282,7 +282,7 @@ class CDataStream
             vch.insert(it, first, last);
     }
 
-    void insert(iterator it, const char* first, const char* last)
+    void insert(iterator it, const value_type* first, const value_type* last)
     {
         if (last == first) return;
         assert(last - first > 0);
diff --git a/src/test/base64_tests.cpp b/src/test/base64_tests.cpp
index 714fccffaac63..99f3ebdfa120c 100644
--- a/src/test/base64_tests.cpp
+++ b/src/test/base64_tests.cpp
@@ -24,6 +24,16 @@ BOOST_AUTO_TEST_CASE(base64_testvectors)
         BOOST_CHECK_EQUAL(strDec, vstrIn[i]);
     }
 
+    {
+        const std::vector<uint8_t> in_u{0xff, 0x01, 0xff};
+        const std::vector<std::byte> in_b{std::byte{0xff}, std::byte{0x01}, std::byte{0xff}};
+        const std::string in_s{"\xff\x01\xff"};
+        const std::string out_exp{"/wH/"};
+        BOOST_CHECK_EQUAL(EncodeBase64(in_u), out_exp);
+        BOOST_CHECK_EQUAL(EncodeBase64(in_b), out_exp);
+        BOOST_CHECK_EQUAL(EncodeBase64(in_s), out_exp);
+    }
+
     // Decoding strings with embedded NUL characters should fail
     bool failure;
     (void)DecodeBase64("invalid\0"s, &failure);
diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
index ba2d879bb716d..7aa4d9b3c3b10 100644
--- a/src/test/streams_tests.cpp
+++ b/src/test/streams_tests.cpp
@@ -172,7 +172,7 @@ BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
     ds.Xor(key);
     BOOST_CHECK_EQUAL(
             std::string(expected_xor.begin(), expected_xor.end()),
-            std::string(ds.begin(), ds.end()));
+            ds.str());
 
     in.push_back('\x0f');
     in.push_back('\xf0');
@@ -189,7 +189,7 @@ BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
     ds.Xor(key);
     BOOST_CHECK_EQUAL(
             std::string(expected_xor.begin(), expected_xor.end()),
-            std::string(ds.begin(), ds.end()));
+            ds.str());
 
     // Multi character key
 
@@ -210,7 +210,7 @@ BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
     ds.Xor(key);
     BOOST_CHECK_EQUAL(
             std::string(expected_xor.begin(), expected_xor.end()),
-            std::string(ds.begin(), ds.end()));
+            ds.str());
 }
 
 BOOST_AUTO_TEST_CASE(streams_buffered_file)
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 4095e2a7396b1..c1fe68c8706ba 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -186,12 +186,25 @@ BOOST_AUTO_TEST_CASE(util_HexStr)
         HexStr(Span<const unsigned char>(ParseHex_expected, ParseHex_expected)),
         "");
 
-    std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
+    {
+        const std::vector<char> in_s{ParseHex_expected, ParseHex_expected + 5};
+        const Span<const uint8_t> in_u{MakeUCharSpan(in_s)};
+        const Span<const std::byte> in_b{MakeByteSpan(in_s)};
+        const std::string out_exp{"04678afdb0"};
+
+        BOOST_CHECK_EQUAL(HexStr(in_u), out_exp);
+        BOOST_CHECK_EQUAL(HexStr(in_s), out_exp);
+        BOOST_CHECK_EQUAL(HexStr(in_b), out_exp);
+    }
+}
 
-    BOOST_CHECK_EQUAL(
-        HexStr(ParseHex_vec),
-        "04678afdb0"
-    );
+BOOST_AUTO_TEST_CASE(span_write_bytes)
+{
+    std::array mut_arr{uint8_t{0xaa}, uint8_t{0xbb}};
+    const auto mut_bytes{MakeWritableByteSpan(mut_arr)};
+    mut_bytes[1] = std::byte{0x11};
+    BOOST_CHECK_EQUAL(mut_arr.at(0), 0xaa);
+    BOOST_CHECK_EQUAL(mut_arr.at(1), 0x11);
 }
 
 BOOST_AUTO_TEST_CASE(util_Join)
diff --git a/src/util/strencodings.cpp b/src/util/strencodings.cpp
index 84d806d65adcc..ed4624c3c5958 100644
--- a/src/util/strencodings.cpp
+++ b/src/util/strencodings.cpp
@@ -138,11 +138,6 @@ std::string EncodeBase64(Span<const unsigned char> input)
     return str;
 }
 
-std::string EncodeBase64(const std::string& str)
-{
-    return EncodeBase64(MakeUCharSpan(str));
-}
-
 std::vector<unsigned char> DecodeBase64(const char* p, bool* pf_invalid)
 {
     static const int8_t decode64_table[256]{
diff --git a/src/util/strencodings.h b/src/util/strencodings.h
index 427f3e2651c24..ab5cf47adfa25 100644
--- a/src/util/strencodings.h
+++ b/src/util/strencodings.h
@@ -49,8 +49,8 @@ bool IsHexNumber(const std::string& str);
 std::vector<unsigned char> DecodeBase64(const char* p, bool* pf_invalid = nullptr);
 std::string DecodeBase64(const std::string& str, bool* pf_invalid = nullptr);
 std::string EncodeBase64(Span<const unsigned char> input);
-std::string EncodeBase64(const std::string& str);
-
+inline std::string EncodeBase64(Span<const std::byte> input) { return EncodeBase64(MakeUCharSpan(input)); }
+inline std::string EncodeBase64(const std::string& str) { return EncodeBase64(MakeUCharSpan(str)); }
 std::vector<unsigned char> DecodeBase32(const char* p, bool* pf_invalid = nullptr);
 std::string DecodeBase32(const std::string& str, bool* pf_invalid = nullptr);
 
@@ -194,6 +194,7 @@ std::optional<T> ToIntegral(const std::string& str)
  */
 std::string HexStr(const Span<const uint8_t> s);
 inline std::string HexStr(const Span<const char> s) { return HexStr(MakeUCharSpan(s)); }
+inline std::string HexStr(const Span<const std::byte> s) { return HexStr(MakeUCharSpan(s)); }
 
 /**
  * Format a paragraph of text to a fixed width, adding spaces for

From 4b29a74904f45486b3807f7ccb5cc5249f5cb577 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 4 Jan 2021 18:37:52 +0100
Subject: [PATCH 06/21] merge bitcoin#20852: allow CSubNet of non-IP networks

---
 src/netaddress.cpp            | 81 +++++++++++++++++++++++++++++------
 src/netaddress.h              | 24 ++++++++++-
 src/test/netbase_tests.cpp    | 21 +++++++--
 test/functional/rpc_setban.py | 16 +++++++
 4 files changed, 123 insertions(+), 19 deletions(-)

diff --git a/src/netaddress.cpp b/src/netaddress.cpp
index 378da0627254b..b571ee4306fdf 100644
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -1125,15 +1125,24 @@ CSubNet::CSubNet(const CNetAddr& addr, const CNetAddr& mask) : CSubNet()
 
 CSubNet::CSubNet(const CNetAddr& addr) : CSubNet()
 {
-    valid = addr.IsIPv4() || addr.IsIPv6();
-    if (!valid) {
+    switch (addr.m_net) {
+    case NET_IPV4:
+    case NET_IPV6:
+        valid = true;
+        assert(addr.m_addr.size() <= sizeof(netmask));
+        memset(netmask, 0xFF, addr.m_addr.size());
+        break;
+    case NET_ONION:
+    case NET_I2P:
+    case NET_CJDNS:
+        valid = true;
+        break;
+    case NET_INTERNAL:
+    case NET_UNROUTABLE:
+    case NET_MAX:
         return;
     }
 
-    assert(addr.m_addr.size() <= sizeof(netmask));
-
-    memset(netmask, 0xFF, addr.m_addr.size());
-
     network = addr;
 }
 
@@ -1145,6 +1154,21 @@ bool CSubNet::Match(const CNetAddr &addr) const
 {
     if (!valid || !addr.IsValid() || network.m_net != addr.m_net)
         return false;
+
+    switch (network.m_net) {
+    case NET_IPV4:
+    case NET_IPV6:
+        break;
+    case NET_ONION:
+    case NET_I2P:
+    case NET_CJDNS:
+    case NET_INTERNAL:
+        return addr == network;
+    case NET_UNROUTABLE:
+    case NET_MAX:
+        return false;
+    }
+
     assert(network.m_addr.size() == addr.m_addr.size());
     for (size_t x = 0; x < addr.m_addr.size(); ++x) {
         if ((addr.m_addr[x] & netmask[x]) != network.m_addr[x]) {
@@ -1156,18 +1180,35 @@ bool CSubNet::Match(const CNetAddr &addr) const
 
 std::string CSubNet::ToString() const
 {
-    assert(network.m_addr.size() <= sizeof(netmask));
+    std::string suffix;
 
-    uint8_t cidr = 0;
+    switch (network.m_net) {
+    case NET_IPV4:
+    case NET_IPV6: {
+        assert(network.m_addr.size() <= sizeof(netmask));
 
-    for (size_t i = 0; i < network.m_addr.size(); ++i) {
-        if (netmask[i] == 0x00) {
-            break;
+        uint8_t cidr = 0;
+
+        for (size_t i = 0; i < network.m_addr.size(); ++i) {
+            if (netmask[i] == 0x00) {
+                break;
+            }
+            cidr += NetmaskBits(netmask[i]);
         }
-        cidr += NetmaskBits(netmask[i]);
+
+        suffix = strprintf("/%u", cidr);
+        break;
+    }
+    case NET_ONION:
+    case NET_I2P:
+    case NET_CJDNS:
+    case NET_INTERNAL:
+    case NET_UNROUTABLE:
+    case NET_MAX:
+        break;
     }
 
-    return network.ToString() + strprintf("/%u", cidr);
+    return network.ToString() + suffix;
 }
 
 bool CSubNet::IsValid() const
@@ -1177,7 +1218,19 @@ bool CSubNet::IsValid() const
 
 bool CSubNet::SanityCheck() const
 {
-    if (!(network.IsIPv4() || network.IsIPv6())) return false;
+    switch (network.m_net) {
+    case NET_IPV4:
+    case NET_IPV6:
+        break;
+    case NET_ONION:
+    case NET_I2P:
+    case NET_CJDNS:
+        return true;
+    case NET_INTERNAL:
+    case NET_UNROUTABLE:
+    case NET_MAX:
+        return false;
+    }
 
     for (size_t x = 0; x < network.m_addr.size(); ++x) {
         if (network.m_addr[x] & ~netmask[x]) return false;
diff --git a/src/netaddress.h b/src/netaddress.h
index 140e8bd288dd6..49800a9085c8a 100644
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -489,11 +489,33 @@ class CSubNet
         bool SanityCheck() const;
 
     public:
+        /**
+         * Construct an invalid subnet (empty, `Match()` always returns false).
+         */
         CSubNet();
+
+        /**
+         * Construct from a given network start and number of bits (CIDR mask).
+         * @param[in] addr Network start. Must be IPv4 or IPv6, otherwise an invalid subnet is
+         * created.
+         * @param[in] mask CIDR mask, must be in [0, 32] for IPv4 addresses and in [0, 128] for
+         * IPv6 addresses. Otherwise an invalid subnet is created.
+         */
         CSubNet(const CNetAddr& addr, uint8_t mask);
+
+        /**
+         * Construct from a given network start and mask.
+         * @param[in] addr Network start. Must be IPv4 or IPv6, otherwise an invalid subnet is
+         * created.
+         * @param[in] mask Network mask, must be of the same type as `addr` and not contain 0-bits
+         * followed by 1-bits. Otherwise an invalid subnet is created.
+         */
         CSubNet(const CNetAddr& addr, const CNetAddr& mask);
 
-        //constructor for single ip subnet (<ipv4>/32 or <ipv6>/128)
+        /**
+         * Construct a single-host subnet.
+         * @param[in] addr The sole address to be contained in the subnet, can also be non-IPv[46].
+         */
         explicit CSubNet(const CNetAddr& addr);
 
         bool Match(const CNetAddr &addr) const;
diff --git a/src/test/netbase_tests.cpp b/src/test/netbase_tests.cpp
index 377f38901376c..30a46c0e05561 100644
--- a/src/test/netbase_tests.cpp
+++ b/src/test/netbase_tests.cpp
@@ -228,8 +228,22 @@ BOOST_AUTO_TEST_CASE(subnet_test)
     // IPv4 address with IPv6 netmask or the other way around.
     BOOST_CHECK(!CSubNet(ResolveIP("1.1.1.1"), ResolveIP("ffff::")).IsValid());
     BOOST_CHECK(!CSubNet(ResolveIP("::1"), ResolveIP("255.0.0.0")).IsValid());
-    // Can't subnet TOR (or any other non-IPv4 and non-IPv6 network).
-    BOOST_CHECK(!CSubNet(ResolveIP("5wyqrzbvrdsumnok.onion"), ResolveIP("255.0.0.0")).IsValid());
+
+    // Create Non-IP subnets.
+
+    const CNetAddr tor_addr{
+        ResolveIP("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion")};
+
+    subnet = CSubNet(tor_addr);
+    BOOST_CHECK(subnet.IsValid());
+    BOOST_CHECK_EQUAL(subnet.ToString(), tor_addr.ToString());
+    BOOST_CHECK(subnet.Match(tor_addr));
+    BOOST_CHECK(
+        !subnet.Match(ResolveIP("kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion")));
+    BOOST_CHECK(!subnet.Match(ResolveIP("1.2.3.4")));
+
+    BOOST_CHECK(!CSubNet(tor_addr, 200).IsValid());
+    BOOST_CHECK(!CSubNet(tor_addr, ResolveIP("255.0.0.0")).IsValid());
 
     subnet = ResolveSubNet("1.2.3.4/255.255.255.255");
     BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
@@ -545,8 +559,7 @@ BOOST_AUTO_TEST_CASE(netbase_dont_resolve_strings_with_embedded_nul_characters)
     BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0"s, ret));
     BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0example.com"s, ret));
     BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0example.com\0"s, ret));
-    // We only do subnetting for IPv4 and IPv6
-    BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion"s, ret));
+    BOOST_CHECK(LookupSubNet("5wyqrzbvrdsumnok.onion"s, ret));
     BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0"s, ret));
     BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0example.com"s, ret));
     BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0example.com\0"s, ret));
diff --git a/test/functional/rpc_setban.py b/test/functional/rpc_setban.py
index f6072b0ab4471..a185b353b3e1c 100755
--- a/test/functional/rpc_setban.py
+++ b/test/functional/rpc_setban.py
@@ -15,6 +15,9 @@ def set_test_params(self):
         self.setup_clean_chain = True
         self.extra_args = [[],[]]
 
+    def is_banned(self, node, addr):
+        return any(e['address'] == addr for e in node.listbanned())
+
     def run_test(self):
         # Node 0 connects to Node 1, check that the noban permission is not granted
         self.connect_nodes(0, 1)
@@ -42,5 +45,18 @@ def run_test(self):
         peerinfo = self.nodes[1].getpeerinfo()[0]
         assert not 'noban' in peerinfo['permissions']
 
+        self.log.info("Test that a non-IP address can be banned/unbanned")
+        node = self.nodes[1]
+        tor_addr = "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"
+        ip_addr = "1.2.3.4"
+        assert(not self.is_banned(node, tor_addr))
+        assert(not self.is_banned(node, ip_addr))
+        node.setban(tor_addr, "add")
+        assert(self.is_banned(node, tor_addr))
+        assert(not self.is_banned(node, ip_addr))
+        node.setban(tor_addr, "remove")
+        assert(not self.is_banned(self.nodes[1], tor_addr))
+        assert(not self.is_banned(node, ip_addr))
+
 if __name__ == '__main__':
     SetBanTests().main()

From 4041d2071670a0ec448292a312606d570b21e97f Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 8 Sep 2023 20:48:57 +0530
Subject: [PATCH 07/21] merge bitcoin#20355: Check for addrv1 compatibility
 before using addrv1 serializer/deserializer on CSubNet

---
 src/test/fuzz/deserialize.cpp | 38 ++++++++++++++++++++++++++---------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index e31eca375cedb..09cbb1644bd84 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -24,6 +24,7 @@
 #include <version.h>
 
 #include <exception>
+#include <optional>
 #include <stdexcept>
 #include <stdint.h>
 #include <unistd.h>
@@ -69,15 +70,19 @@ T Deserialize(CDataStream ds)
 }
 
 template <typename T>
-void DeserializeFromFuzzingInput(const std::vector<uint8_t>& buffer, T& obj)
+void DeserializeFromFuzzingInput(const std::vector<uint8_t>& buffer, T& obj, const std::optional<int>& protocol_version = {})
 {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
-    try {
-        int version;
-        ds >> version;
-        ds.SetVersion(version);
-    } catch (const std::ios_base::failure&) {
-        throw invalid_fuzzing_input_exception();
+    if (protocol_version) {
+        ds.SetVersion(*protocol_version);
+    } else {
+        try {
+            int version;
+            ds >> version;
+            ds.SetVersion(version);
+        } catch (const std::ios_base::failure&) {
+            throw invalid_fuzzing_input_exception();
+        }
     }
     try {
         ds >> obj;
@@ -141,9 +146,15 @@ FUZZ_TARGET_DESERIALIZE(script_deserialize, {
         DeserializeFromFuzzingInput(buffer, script);
 })
 FUZZ_TARGET_DESERIALIZE(sub_net_deserialize, {
-        CSubNet sub_net;
-        DeserializeFromFuzzingInput(buffer, sub_net);
-        AssertEqualAfterSerializeDeserialize(sub_net);
+        CSubNet sub_net_1;
+        DeserializeFromFuzzingInput(buffer, sub_net_1, INIT_PROTO_VERSION);
+        AssertEqualAfterSerializeDeserialize(sub_net_1, INIT_PROTO_VERSION);
+        CSubNet sub_net_2;
+        DeserializeFromFuzzingInput(buffer, sub_net_2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+        AssertEqualAfterSerializeDeserialize(sub_net_2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+        CSubNet sub_net_3;
+        DeserializeFromFuzzingInput(buffer, sub_net_3);
+        AssertEqualAfterSerializeDeserialize(sub_net_3, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
 FUZZ_TARGET_DESERIALIZE(tx_in_deserialize, {
         CTxIn tx_in;
@@ -231,6 +242,13 @@ FUZZ_TARGET_DESERIALIZE(service_deserialize, {
             AssertEqualAfterSerializeDeserialize(s);
         }
         AssertEqualAfterSerializeDeserialize(s, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+        CService s1;
+        DeserializeFromFuzzingInput(buffer, s1, INIT_PROTO_VERSION);
+        AssertEqualAfterSerializeDeserialize(s1, INIT_PROTO_VERSION);
+        assert(s1.IsAddrV1Compatible());
+        CService s2;
+        DeserializeFromFuzzingInput(buffer, s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+        AssertEqualAfterSerializeDeserialize(s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
 FUZZ_TARGET_DESERIALIZE(messageheader_deserialize, {
         CMessageHeader mh;

From aa76506bc96fbb7d09c0073e5d731eecdca111a3 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 10 Sep 2023 19:40:08 +0530
Subject: [PATCH 08/21] partial bitcoin#21560: Add Tor v3 hardcoded seeds

excludes:
- 2a257de113fd31539b68c28c47ef94f257b6e427
- 9b29d5df7fc555eaea42029f334f2995c6ccde3d
---
 contrib/seeds/generate-seeds.py | 103 +++++----
 src/chainparams.cpp             |   4 +-
 src/chainparams.h               |   9 +-
 src/chainparamsseeds.h          | 363 ++++++++++++++++----------------
 src/net.cpp                     |  17 +-
 5 files changed, 256 insertions(+), 240 deletions(-)

diff --git a/contrib/seeds/generate-seeds.py b/contrib/seeds/generate-seeds.py
index d905658f6594d..fb714d61a57ef 100755
--- a/contrib/seeds/generate-seeds.py
+++ b/contrib/seeds/generate-seeds.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2017 Wladimir J. van der Laan
+# Copyright (c) 2014-2021 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 '''
@@ -13,19 +13,13 @@
 
 These files must consist of lines in the format
 
-    <ip>
     <ip>:<port>
-    [<ipv6>]
     [<ipv6>]:<port>
-    <onion>.onion
-    0xDDBBCCAA (IPv4 little-endian old pnSeeds format)
+    <onion>.onion:<port>
 
 The output will be two data structures with the peers in binary format:
 
-   static SeedSpec6 pnSeed6_main[]={
-   ...
-   }
-   static SeedSpec6 pnSeed6_test[]={
+   static const uint8_t chainparams_seed_{main,test}[]={
    ...
    }
 
@@ -33,24 +27,33 @@
 '''
 
 from base64 import b32decode
-from binascii import a2b_hex
+from enum import Enum
+import struct
 import sys
 import os
 import re
 
-# ipv4 in ipv6 prefix
-pchIPv4 = bytearray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff])
-# tor-specific ipv6 prefix
-pchOnionCat = bytearray([0xFD,0x87,0xD8,0x7E,0xEB,0x43])
-
-def name_to_ipv6(addr):
-    if len(addr)>6 and addr.endswith('.onion'):
+class BIP155Network(Enum):
+    IPV4 = 1
+    IPV6 = 2
+    TORV2 = 3
+    TORV3 = 4
+    I2P = 5
+    CJDNS = 6
+
+def name_to_bip155(addr):
+    '''Convert address string to BIP155 (networkID, addr) tuple.'''
+    if addr.endswith('.onion'):
         vchAddr = b32decode(addr[0:-6], True)
-        if len(vchAddr) != 16-len(pchOnionCat):
+        if len(vchAddr) == 10:
+            return (BIP155Network.TORV2, vchAddr)
+        elif len(vchAddr) == 35:
+            assert(vchAddr[34] == 3)
+            return (BIP155Network.TORV3, vchAddr[:32])
+        else:
             raise ValueError('Invalid onion %s' % vchAddr)
-        return pchOnionCat + vchAddr
     elif '.' in addr: # IPv4
-        return pchIPv4 + bytearray((int(x) for x in addr.split('.')))
+        return (BIP155Network.IPV4, bytes((int(x) for x in addr.split('.'))))
     elif ':' in addr: # IPv6
         sub = [[], []] # prefix, suffix
         x = 0
@@ -67,13 +70,12 @@ def name_to_ipv6(addr):
                 sub[x].append(val & 0xff)
         nullbytes = 16 - len(sub[0]) - len(sub[1])
         assert((x == 0 and nullbytes == 0) or (x == 1 and nullbytes > 0))
-        return bytearray(sub[0] + ([0] * nullbytes) + sub[1])
-    elif addr.startswith('0x'): # IPv4-in-little-endian
-        return pchIPv4 + bytearray(reversed(a2b_hex(addr[2:])))
+        return (BIP155Network.IPV6, bytes(sub[0] + ([0] * nullbytes) + sub[1]))
     else:
         raise ValueError('Could not parse address %s' % addr)
 
-def parse_spec(s, defaultport):
+def parse_spec(s):
+    '''Convert endpoint string to BIP155 (networkID, addr, port) tuple.'''
     match = re.match(r'\[([0-9a-fA-F:]+)\](?::([0-9]+))?$', s)
     if match: # ipv6
         host = match.group(1)
@@ -85,17 +87,39 @@ def parse_spec(s, defaultport):
         (host,_,port) = s.partition(':')
 
     if not port:
-        port = defaultport
+        port = 0
     else:
         port = int(port)
 
-    host = name_to_ipv6(host)
+    host = name_to_bip155(host)
 
-    return (host,port)
+    return host + (port, )
 
-def process_nodes(g, f, structname, defaultport):
-    g.write('static SeedSpec6 %s[] = {\n' % structname)
-    first = True
+def ser_compact_size(l):
+    r = b""
+    if l < 253:
+        r = struct.pack("B", l)
+    elif l < 0x10000:
+        r = struct.pack("<BH", 253, l)
+    elif l < 0x100000000:
+        r = struct.pack("<BI", 254, l)
+    else:
+        r = struct.pack("<BQ", 255, l)
+    return r
+
+def bip155_serialize(spec):
+    '''
+    Serialize (networkID, addr, port) tuple to BIP155 binary format.
+    '''
+    r = b""
+    r += struct.pack('B', spec[0].value)
+    r += ser_compact_size(len(spec[1]))
+    r += spec[1]
+    r += struct.pack('>H', spec[2])
+    return r
+
+def process_nodes(g, f, structname):
+    g.write('static const uint8_t %s[] = {\n' % structname)
     for line in f:
         comment = line.find('#')
         if comment != -1:
@@ -103,14 +127,12 @@ def process_nodes(g, f, structname, defaultport):
         line = line.strip()
         if not line:
             continue
-        if not first:
-            g.write(',\n')
-        first = False
 
-        (host,port) = parse_spec(line, defaultport)
-        hoststr = ','.join(('0x%02x' % b) for b in host)
-        g.write('    {{%s}, %i}' % (hoststr, port))
-    g.write('\n};\n')
+        spec = parse_spec(line)
+        blob = bip155_serialize(spec)
+        hoststr = ','.join(('0x%02x' % b) for b in blob)
+        g.write(f'    {hoststr},\n')
+    g.write('};\n')
 
 def main():
     if len(sys.argv)<2:
@@ -124,14 +146,13 @@ def main():
     g.write(' * List of fixed seed nodes for the dash network\n')
     g.write(' * AUTOGENERATED by contrib/seeds/generate-seeds.py\n')
     g.write(' *\n')
-    g.write(' * Each line contains a 16-byte IPv6 address and a port.\n')
-    g.write(' * IPv4 as well as onion addresses are wrapped inside an IPv6 address accordingly.\n')
+    g.write(' * Each line contains a BIP155 serialized (networkID, addr, port) tuple.\n')
     g.write(' */\n')
     with open(os.path.join(indir,'nodes_main.txt'), 'r', encoding="utf8") as f:
-        process_nodes(g, f, 'pnSeed6_main', 9999)
+        process_nodes(g, f, 'chainparams_seed_main')
     g.write('\n')
     with open(os.path.join(indir,'nodes_test.txt'), 'r', encoding="utf8") as f:
-        process_nodes(g, f, 'pnSeed6_test', 19999)
+        process_nodes(g, f, 'chainparams_seed_test')
     g.write('#endif // BITCOIN_CHAINPARAMSSEEDS_H\n')
 
 if __name__ == '__main__':
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 5eff1ae6369be..151ba48622060 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -245,7 +245,7 @@ class CMainParams : public CChainParams {
         // Dash BIP44 coin type is '5'
         nExtCoinType = 5;
 
-        vFixedSeeds = std::vector<SeedSpec6>(std::begin(pnSeed6_main), std::end(pnSeed6_main));
+        vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
 
         // long living quorum params
         AddLLMQ(Consensus::LLMQType::LLMQ_50_60);
@@ -417,7 +417,7 @@ class CTestNetParams : public CChainParams {
         assert(genesis.hashMerkleRoot == uint256S("0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7"));
 
         vFixedSeeds.clear();
-        vFixedSeeds = std::vector<SeedSpec6>(std::begin(pnSeed6_test), std::end(pnSeed6_test));
+        vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
 
         vSeeds.clear();
         // nodes with support for servicebits filtering should be at the top
diff --git a/src/chainparams.h b/src/chainparams.h
index 59404c9d037c7..3218f81b07992 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -19,11 +19,6 @@
 #include <string>
 #include <vector>
 
-struct SeedSpec6 {
-    uint8_t addr[16];
-    uint16_t port;
-};
-
 typedef std::map<int, uint256> MapCheckpoints;
 
 struct CCheckpointData {
@@ -127,7 +122,7 @@ class CChainParams
     const std::vector<std::string>& DNSSeeds() const { return vSeeds; }
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
     int ExtCoinType() const { return nExtCoinType; }
-    const std::vector<SeedSpec6>& FixedSeeds() const { return vFixedSeeds; }
+    const std::vector<uint8_t>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
 
     //! Get allowed assumeutxo configuration.
@@ -161,7 +156,7 @@ class CChainParams
     std::string strNetworkID;
     CBlock genesis;
     CBlock devnetGenesis;
-    std::vector<SeedSpec6> vFixedSeeds;
+    std::vector<uint8_t> vFixedSeeds;
     bool fDefaultConsistencyChecks;
     bool fRequireStandard;
     bool fRequireRoutableExternalIP;
diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h
index ec0c31f85f56f..2ca3968f5ced7 100644
--- a/src/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@@ -4,190 +4,189 @@
  * List of fixed seed nodes for the dash network
  * AUTOGENERATED by contrib/seeds/generate-seeds.py
  *
- * Each line contains a 16-byte IPv6 address and a port.
- * IPv4 as well as onion addresses are wrapped inside an IPv6 address accordingly.
+ * Each line contains a BIP155 serialized (networkID, addr, port) tuple.
  */
-static SeedSpec6 pnSeed6_main[] = {
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x02,0x38,0xd5,0xdd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x02,0x43,0xbe}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x02,0x49,0x3a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x09,0xed,0x22}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x4f,0x6d,0xf3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x65,0x2c,0xe1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xa1,0x57,0xb8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xa1,0x78,0x23}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xa1,0x7e,0x07}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xb5,0xca,0x12}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0x8b,0xf4,0x09}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0x9d,0x81,0x94}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x51,0xf6,0x2a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x53,0x85,0x0a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0x53,0x85,0xc4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1f,0x0a,0x61,0x24}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1f,0x94,0x63,0xf2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1f,0xb2,0x04,0x32}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xd1,0xed,0xf2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0x12,0xe3,0x38}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0x61,0xe3,0x15}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2a,0xc2,0x85,0x77}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2b,0xe5,0x4d,0x2e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x21,0x18,0x18}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x38,0x40,0x6b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x38,0x46,0x71}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x3f,0x6b,0x5a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x47,0x9e,0x3a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x47,0x9e,0x42}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x47,0x9f,0x68}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4c,0x27,0xf1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4c,0x59,0x3f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4f,0x2e,0x47}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x55,0x75,0x2d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x55,0x75,0xca}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x56,0xa2,0x53}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x56,0xa2,0x55}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x56,0xa2,0x9a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x1e,0xbd,0xbd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x1e,0xbd,0xd5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x1e,0xbd,0xd6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x1e,0xbd,0xfb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x24,0x28,0xf2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0xfe,0xf1,0x18}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0xfe,0xf1,0x1c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x38,0x76,0x14}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x5b,0x98,0xe8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x62,0x7b,0x6a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x32,0x11,0xaf,0x5b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x0f,0x60,0xce}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x0f,0x75,0x2a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x0f,0xfe,0xe0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x26,0xb3,0xe6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x53,0xbf,0xd2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x9e,0xa9,0xed}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xca,0x8d,0x3c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x36,0xa4,0xb9,0x60}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x36,0xda,0xda,0x2b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0xab,0xbe,0x8c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x40,0xfb,0x41,0xce}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0xac,0x0c,0x56}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0xf4,0xf3,0x45}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x43,0xca,0x14,0xe6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x3d,0x6b,0xd7}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x3d,0x6b,0xd9}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x3d,0x6b,0xf2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4d,0xdc,0xd4,0xb3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x50,0x55,0x88,0xf8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x50,0xd1,0xea,0xaa}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x50,0xf0,0x84,0xe7}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0x02,0xf0,0x76}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0x47,0x0d,0xa5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0xab,0x02,0xf5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0xe2,0xdf,0x99}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xca,0xe6,0x53}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x15,0x17}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x15,0xb3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x19,0x69}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x19,0xc1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x54,0x34,0x74,0x34}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x54,0xf2,0xb3,0xcc}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0x11,0xf8,0x5b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xce,0xa5,0x59}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xce,0xa5,0x5a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd1,0xf1,0x23}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd1,0xf1,0xbe}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd1,0xf2,0x04}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd1,0xf2,0x62}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x57,0x62,0xfd,0x56}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0x28,0x0d,0x2c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0x2d,0x43,0x36}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0x2d,0x43,0x8a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5d,0xbe,0x8c,0x72}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x33,0x8d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x33,0x92}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x35,0x27}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd3,0xc4,0x22}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd7,0x2d,0xe1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd7,0x6e,0x78}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0xa0,0x5f,0xdb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0xa0,0x5f,0xe1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x68,0x80,0xef,0xd6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6a,0x34,0x79,0xda}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0xa1,0x18,0x5a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0xbf,0x65,0xd4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6c,0x3d,0xf7,0x46}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x7b,0xc1,0x40,0xa6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8a,0x44,0x1c,0x08}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8b,0x09,0xc7,0xf0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8c,0xee,0xd2,0x22}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8d,0x5f,0x35,0x6b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8e,0xca,0xcd,0x65}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x90,0x7e,0x8e,0xa7}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0x83,0x1c,0x42}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0x83,0x1c,0x44}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0x83,0x1d,0xd6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0x83,0x2a,0x60}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x92,0xb9,0xaf,0xce}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x98,0x43,0x45,0xe4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9e,0x65,0xa2,0x4a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9e,0x65,0xa8,0x1c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa7,0x47,0x33,0xcd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa7,0x56,0x4f,0x3e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa8,0x77,0x50,0x04}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa8,0xeb,0x51,0x55}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa8,0xeb,0x55,0xf1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xaa,0x4b,0xaa,0x87}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0xf9,0x15,0x7a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0xf9,0x1a,0x14}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xae,0x22,0xe9,0xc9}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xae,0x22,0xe9,0xca}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xae,0x22,0xe9,0xcb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xae,0x22,0xe9,0xcc}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0x66,0x41,0x91}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0x7b,0x39,0xc6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0x7b,0x39,0xc8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0x7b,0x39,0xcb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0x7b,0x39,0xcd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0xdf,0x88,0x2b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x3f,0x79,0x81}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x9d,0x5b,0x7e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x9d,0x5b,0xb0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x9d,0x5b,0xb3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x05,0x34,0xe0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x3e,0x97,0xaa}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x3e,0x97,0xae}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x40,0x68,0xde}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x40,0x68,0xdf}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x8e,0xd4,0x90}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xa5,0xab,0x75}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xaf,0x9e,0x28}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xb1,0x3b,0x25}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xe4,0x53,0x71}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xe4,0x53,0x9c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xf3,0x0a,0x70}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xf3,0x0a,0x73}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x28,0xf1,0x6a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x7f,0xe6,0x28}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x7f,0xed,0xf3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xf4,0x75,0x0c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xa9,0x06,0x19}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0x1d,0x38,0x58}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0x1d,0x3b,0x60}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0xed,0x51,0xe0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc2,0x1a,0xe8,0xc3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc2,0xb6,0x4b,0x88}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc3,0xb5,0xd2,0x11}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc3,0xb5,0xd3,0x40}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xca,0x3d,0xc6,0x70}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xca,0x3d,0xf8,0xd3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0x6b,0xd9,0x3e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0xbd,0x93,0x5f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0xbd,0x93,0xb2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0xbd,0x97,0x5e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xde,0x74,0x40,0xe5}, 9999}
+static const uint8_t chainparams_seed_main[] = {
+    0x01,0x04,0x02,0x38,0xd5,0xdd,0x27,0x0f,
+    0x01,0x04,0x05,0x02,0x43,0xbe,0x27,0x0f,
+    0x01,0x04,0x05,0x02,0x49,0x3a,0x27,0x0f,
+    0x01,0x04,0x05,0x09,0xed,0x22,0x27,0x0f,
+    0x01,0x04,0x05,0x4f,0x6d,0xf3,0x27,0x0f,
+    0x01,0x04,0x05,0x65,0x2c,0xe1,0x27,0x0f,
+    0x01,0x04,0x05,0xa1,0x57,0xb8,0x27,0x0f,
+    0x01,0x04,0x05,0xa1,0x78,0x23,0x27,0x0f,
+    0x01,0x04,0x05,0xa1,0x7e,0x07,0x27,0x0f,
+    0x01,0x04,0x05,0xb5,0xca,0x12,0x27,0x0f,
+    0x01,0x04,0x12,0x8b,0xf4,0x09,0x27,0x0f,
+    0x01,0x04,0x12,0x9d,0x81,0x94,0x27,0x0f,
+    0x01,0x04,0x17,0x51,0xf6,0x2a,0x27,0x0f,
+    0x01,0x04,0x17,0x53,0x85,0x0a,0x27,0x0f,
+    0x01,0x04,0x17,0x53,0x85,0xc4,0x27,0x0f,
+    0x01,0x04,0x1f,0x0a,0x61,0x24,0x27,0x0f,
+    0x01,0x04,0x1f,0x94,0x63,0xf2,0x27,0x0f,
+    0x01,0x04,0x1f,0xb2,0x04,0x32,0x27,0x0f,
+    0x01,0x04,0x22,0xd1,0xed,0xf2,0x27,0x0f,
+    0x01,0x04,0x25,0x12,0xe3,0x38,0x27,0x0f,
+    0x01,0x04,0x25,0x61,0xe3,0x15,0x27,0x0f,
+    0x01,0x04,0x2a,0xc2,0x85,0x77,0x27,0x0f,
+    0x01,0x04,0x2b,0xe5,0x4d,0x2e,0x27,0x0f,
+    0x01,0x04,0x2d,0x21,0x18,0x18,0x27,0x0f,
+    0x01,0x04,0x2d,0x38,0x40,0x6b,0x27,0x0f,
+    0x01,0x04,0x2d,0x38,0x46,0x71,0x27,0x0f,
+    0x01,0x04,0x2d,0x3f,0x6b,0x5a,0x27,0x0f,
+    0x01,0x04,0x2d,0x47,0x9e,0x3a,0x27,0x0f,
+    0x01,0x04,0x2d,0x47,0x9e,0x42,0x27,0x0f,
+    0x01,0x04,0x2d,0x47,0x9f,0x68,0x27,0x0f,
+    0x01,0x04,0x2d,0x4c,0x27,0xf1,0x27,0x0f,
+    0x01,0x04,0x2d,0x4c,0x59,0x3f,0x27,0x0f,
+    0x01,0x04,0x2d,0x4f,0x2e,0x47,0x27,0x0f,
+    0x01,0x04,0x2d,0x55,0x75,0x2d,0x27,0x0f,
+    0x01,0x04,0x2d,0x55,0x75,0xca,0x27,0x0f,
+    0x01,0x04,0x2d,0x56,0xa2,0x53,0x27,0x0f,
+    0x01,0x04,0x2d,0x56,0xa2,0x55,0x27,0x0f,
+    0x01,0x04,0x2d,0x56,0xa2,0x9a,0x27,0x0f,
+    0x01,0x04,0x2e,0x1e,0xbd,0xbd,0x27,0x0f,
+    0x01,0x04,0x2e,0x1e,0xbd,0xd5,0x27,0x0f,
+    0x01,0x04,0x2e,0x1e,0xbd,0xd6,0x27,0x0f,
+    0x01,0x04,0x2e,0x1e,0xbd,0xfb,0x27,0x0f,
+    0x01,0x04,0x2e,0x24,0x28,0xf2,0x27,0x0f,
+    0x01,0x04,0x2e,0xfe,0xf1,0x18,0x27,0x0f,
+    0x01,0x04,0x2e,0xfe,0xf1,0x1c,0x27,0x0f,
+    0x01,0x04,0x2f,0x38,0x76,0x14,0x27,0x0f,
+    0x01,0x04,0x2f,0x5b,0x98,0xe8,0x27,0x0f,
+    0x01,0x04,0x2f,0x62,0x7b,0x6a,0x27,0x0f,
+    0x01,0x04,0x32,0x11,0xaf,0x5b,0x27,0x0f,
+    0x01,0x04,0x33,0x0f,0x60,0xce,0x27,0x0f,
+    0x01,0x04,0x33,0x0f,0x75,0x2a,0x27,0x0f,
+    0x01,0x04,0x33,0x0f,0xfe,0xe0,0x27,0x0f,
+    0x01,0x04,0x33,0x26,0xb3,0xe6,0x27,0x0f,
+    0x01,0x04,0x33,0x53,0xbf,0xd2,0x27,0x0f,
+    0x01,0x04,0x33,0x9e,0xa9,0xed,0x27,0x0f,
+    0x01,0x04,0x34,0xca,0x8d,0x3c,0x27,0x0f,
+    0x01,0x04,0x36,0xa4,0xb9,0x60,0x27,0x0f,
+    0x01,0x04,0x36,0xda,0xda,0x2b,0x27,0x0f,
+    0x01,0x04,0x3e,0xab,0xbe,0x8c,0x27,0x0f,
+    0x01,0x04,0x40,0xfb,0x41,0xce,0x27,0x0f,
+    0x01,0x04,0x42,0xac,0x0c,0x56,0x27,0x0f,
+    0x01,0x04,0x42,0xf4,0xf3,0x45,0x27,0x0f,
+    0x01,0x04,0x43,0xca,0x14,0xe6,0x27,0x0f,
+    0x01,0x04,0x45,0x3d,0x6b,0xd7,0x27,0x0f,
+    0x01,0x04,0x45,0x3d,0x6b,0xd9,0x27,0x0f,
+    0x01,0x04,0x45,0x3d,0x6b,0xf2,0x27,0x0f,
+    0x01,0x04,0x4d,0xdc,0xd4,0xb3,0x27,0x0f,
+    0x01,0x04,0x50,0x55,0x88,0xf8,0x27,0x0f,
+    0x01,0x04,0x50,0xd1,0xea,0xaa,0x27,0x0f,
+    0x01,0x04,0x50,0xf0,0x84,0xe7,0x27,0x0f,
+    0x01,0x04,0x51,0x02,0xf0,0x76,0x27,0x0f,
+    0x01,0x04,0x51,0x47,0x0d,0xa5,0x27,0x0f,
+    0x01,0x04,0x51,0xab,0x02,0xf5,0x27,0x0f,
+    0x01,0x04,0x51,0xe2,0xdf,0x99,0x27,0x0f,
+    0x01,0x04,0x52,0xca,0xe6,0x53,0x27,0x0f,
+    0x01,0x04,0x52,0xd3,0x15,0x17,0x27,0x0f,
+    0x01,0x04,0x52,0xd3,0x15,0xb3,0x27,0x0f,
+    0x01,0x04,0x52,0xd3,0x19,0x69,0x27,0x0f,
+    0x01,0x04,0x52,0xd3,0x19,0xc1,0x27,0x0f,
+    0x01,0x04,0x54,0x34,0x74,0x34,0x27,0x0f,
+    0x01,0x04,0x54,0xf2,0xb3,0xcc,0x27,0x0f,
+    0x01,0x04,0x55,0x11,0xf8,0x5b,0x27,0x0f,
+    0x01,0x04,0x55,0xce,0xa5,0x59,0x27,0x0f,
+    0x01,0x04,0x55,0xce,0xa5,0x5a,0x27,0x0f,
+    0x01,0x04,0x55,0xd1,0xf1,0x23,0x27,0x0f,
+    0x01,0x04,0x55,0xd1,0xf1,0xbe,0x27,0x0f,
+    0x01,0x04,0x55,0xd1,0xf2,0x04,0x27,0x0f,
+    0x01,0x04,0x55,0xd1,0xf2,0x62,0x27,0x0f,
+    0x01,0x04,0x57,0x62,0xfd,0x56,0x27,0x0f,
+    0x01,0x04,0x59,0x28,0x0d,0x2c,0x27,0x0f,
+    0x01,0x04,0x59,0x2d,0x43,0x36,0x27,0x0f,
+    0x01,0x04,0x59,0x2d,0x43,0x8a,0x27,0x0f,
+    0x01,0x04,0x5d,0xbe,0x8c,0x72,0x27,0x0f,
+    0x01,0x04,0x5f,0xb7,0x33,0x8d,0x27,0x0f,
+    0x01,0x04,0x5f,0xb7,0x33,0x92,0x27,0x0f,
+    0x01,0x04,0x5f,0xb7,0x35,0x27,0x27,0x0f,
+    0x01,0x04,0x5f,0xd3,0xc4,0x22,0x27,0x0f,
+    0x01,0x04,0x5f,0xd7,0x2d,0xe1,0x27,0x0f,
+    0x01,0x04,0x5f,0xd7,0x6e,0x78,0x27,0x0f,
+    0x01,0x04,0x67,0xa0,0x5f,0xdb,0x27,0x0f,
+    0x01,0x04,0x67,0xa0,0x5f,0xe1,0x27,0x0f,
+    0x01,0x04,0x68,0x80,0xef,0xd6,0x27,0x0f,
+    0x01,0x04,0x6a,0x34,0x79,0xda,0x27,0x0f,
+    0x01,0x04,0x6b,0xa1,0x18,0x5a,0x27,0x0f,
+    0x01,0x04,0x6b,0xbf,0x65,0xd4,0x27,0x0f,
+    0x01,0x04,0x6c,0x3d,0xf7,0x46,0x27,0x0f,
+    0x01,0x04,0x7b,0xc1,0x40,0xa6,0x27,0x0f,
+    0x01,0x04,0x8a,0x44,0x1c,0x08,0x27,0x0f,
+    0x01,0x04,0x8b,0x09,0xc7,0xf0,0x27,0x0f,
+    0x01,0x04,0x8c,0xee,0xd2,0x22,0x27,0x0f,
+    0x01,0x04,0x8d,0x5f,0x35,0x6b,0x27,0x0f,
+    0x01,0x04,0x8e,0xca,0xcd,0x65,0x27,0x0f,
+    0x01,0x04,0x90,0x7e,0x8e,0xa7,0x27,0x0f,
+    0x01,0x04,0x91,0x83,0x1c,0x42,0x27,0x0f,
+    0x01,0x04,0x91,0x83,0x1c,0x44,0x27,0x0f,
+    0x01,0x04,0x91,0x83,0x1d,0xd6,0x27,0x0f,
+    0x01,0x04,0x91,0x83,0x2a,0x60,0x27,0x0f,
+    0x01,0x04,0x92,0xb9,0xaf,0xce,0x27,0x0f,
+    0x01,0x04,0x98,0x43,0x45,0xe4,0x27,0x0f,
+    0x01,0x04,0x9e,0x65,0xa2,0x4a,0x27,0x0f,
+    0x01,0x04,0x9e,0x65,0xa8,0x1c,0x27,0x0f,
+    0x01,0x04,0xa7,0x47,0x33,0xcd,0x27,0x0f,
+    0x01,0x04,0xa7,0x56,0x4f,0x3e,0x27,0x0f,
+    0x01,0x04,0xa8,0x77,0x50,0x04,0x27,0x0f,
+    0x01,0x04,0xa8,0xeb,0x51,0x55,0x27,0x0f,
+    0x01,0x04,0xa8,0xeb,0x55,0xf1,0x27,0x0f,
+    0x01,0x04,0xaa,0x4b,0xaa,0x87,0x27,0x0f,
+    0x01,0x04,0xad,0xf9,0x15,0x7a,0x27,0x0f,
+    0x01,0x04,0xad,0xf9,0x1a,0x14,0x27,0x0f,
+    0x01,0x04,0xae,0x22,0xe9,0xc9,0x27,0x0f,
+    0x01,0x04,0xae,0x22,0xe9,0xca,0x27,0x0f,
+    0x01,0x04,0xae,0x22,0xe9,0xcb,0x27,0x0f,
+    0x01,0x04,0xae,0x22,0xe9,0xcc,0x27,0x0f,
+    0x01,0x04,0xb0,0x66,0x41,0x91,0x27,0x0f,
+    0x01,0x04,0xb0,0x7b,0x39,0xc6,0x27,0x0f,
+    0x01,0x04,0xb0,0x7b,0x39,0xc8,0x27,0x0f,
+    0x01,0x04,0xb0,0x7b,0x39,0xcb,0x27,0x0f,
+    0x01,0x04,0xb0,0x7b,0x39,0xcd,0x27,0x0f,
+    0x01,0x04,0xb0,0xdf,0x88,0x2b,0x27,0x0f,
+    0x01,0x04,0xb2,0x3f,0x79,0x81,0x27,0x0f,
+    0x01,0x04,0xb2,0x9d,0x5b,0x7e,0x27,0x0f,
+    0x01,0x04,0xb2,0x9d,0x5b,0xb0,0x27,0x0f,
+    0x01,0x04,0xb2,0x9d,0x5b,0xb3,0x27,0x0f,
+    0x01,0x04,0xb9,0x05,0x34,0xe0,0x27,0x0f,
+    0x01,0x04,0xb9,0x3e,0x97,0xaa,0x27,0x0f,
+    0x01,0x04,0xb9,0x3e,0x97,0xae,0x27,0x0f,
+    0x01,0x04,0xb9,0x40,0x68,0xde,0x27,0x0f,
+    0x01,0x04,0xb9,0x40,0x68,0xdf,0x27,0x0f,
+    0x01,0x04,0xb9,0x8e,0xd4,0x90,0x27,0x0f,
+    0x01,0x04,0xb9,0xa5,0xab,0x75,0x27,0x0f,
+    0x01,0x04,0xb9,0xaf,0x9e,0x28,0x27,0x0f,
+    0x01,0x04,0xb9,0xb1,0x3b,0x25,0x27,0x0f,
+    0x01,0x04,0xb9,0xe4,0x53,0x71,0x27,0x0f,
+    0x01,0x04,0xb9,0xe4,0x53,0x9c,0x27,0x0f,
+    0x01,0x04,0xb9,0xf3,0x0a,0x70,0x27,0x0f,
+    0x01,0x04,0xb9,0xf3,0x0a,0x73,0x27,0x0f,
+    0x01,0x04,0xbc,0x28,0xf1,0x6a,0x27,0x0f,
+    0x01,0x04,0xbc,0x7f,0xe6,0x28,0x27,0x0f,
+    0x01,0x04,0xbc,0x7f,0xed,0xf3,0x27,0x0f,
+    0x01,0x04,0xbc,0xf4,0x75,0x0c,0x27,0x0f,
+    0x01,0x04,0xc0,0xa9,0x06,0x19,0x27,0x0f,
+    0x01,0x04,0xc1,0x1d,0x38,0x58,0x27,0x0f,
+    0x01,0x04,0xc1,0x1d,0x3b,0x60,0x27,0x0f,
+    0x01,0x04,0xc1,0xed,0x51,0xe0,0x27,0x0f,
+    0x01,0x04,0xc2,0x1a,0xe8,0xc3,0x27,0x0f,
+    0x01,0x04,0xc2,0xb6,0x4b,0x88,0x27,0x0f,
+    0x01,0x04,0xc3,0xb5,0xd2,0x11,0x27,0x0f,
+    0x01,0x04,0xc3,0xb5,0xd3,0x40,0x27,0x0f,
+    0x01,0x04,0xca,0x3d,0xc6,0x70,0x27,0x0f,
+    0x01,0x04,0xca,0x3d,0xf8,0xd3,0x27,0x0f,
+    0x01,0x04,0xd8,0x6b,0xd9,0x3e,0x27,0x0f,
+    0x01,0x04,0xd8,0xbd,0x93,0x5f,0x27,0x0f,
+    0x01,0x04,0xd8,0xbd,0x93,0xb2,0x27,0x0f,
+    0x01,0x04,0xd8,0xbd,0x97,0x5e,0x27,0x0f,
+    0x01,0x04,0xde,0x74,0x40,0xe5,0x27,0x0f,
 };
 
-static SeedSpec6 pnSeed6_test[] = {
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2b,0xe5,0x4d,0x2e}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4d,0xa7,0xf7}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x3e,0xcb,0xf9}, 19999}
+static const uint8_t chainparams_seed_test[] = {
+    0x01,0x04,0x2b,0xe5,0x4d,0x2e,0x4e,0x1f,
+    0x01,0x04,0x2d,0x4d,0xa7,0xf7,0x4e,0x1f,
+    0x01,0x04,0xb2,0x3e,0xcb,0xf9,0x4e,0x1f,
 };
 #endif // BITCOIN_CHAINPARAMSSEEDS_H
diff --git a/src/net.cpp b/src/net.cpp
index 65f63fc339ef1..e0e231218225a 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -166,8 +166,8 @@ bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
     return nBestScore >= 0;
 }
 
-//! Convert the pnSeed6 array into usable address objects.
-static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn)
+//! Convert the serialized seeds into usable address objects.
+static std::vector<CAddress> ConvertSeeds(const std::vector<uint8_t> &vSeedsIn)
 {
     // It'll only connect to one or two seed nodes because once it connects,
     // it'll get a pile of addresses with newer timestamps.
@@ -175,13 +175,14 @@ static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn
     // weeks ago.
     const int64_t nOneWeek = 7*24*60*60;
     std::vector<CAddress> vSeedsOut;
-    vSeedsOut.reserve(vSeedsIn.size());
     FastRandomContext rng;
-    for (const auto& seed_in : vSeedsIn) {
-        struct in6_addr ip;
-        memcpy(&ip, seed_in.addr, sizeof(ip));
-        CAddress addr(CService(ip, seed_in.port), GetDesirableServiceFlags(NODE_NONE));
+    CDataStream s(vSeedsIn, SER_NETWORK, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    while (!s.eof()) {
+        CService endpoint;
+        s >> endpoint;
+        CAddress addr{endpoint, GetDesirableServiceFlags(NODE_NONE)};
         addr.nTime = GetTime() - rng.randrange(nOneWeek) - nOneWeek;
+        LogPrint(BCLog::NET, "Added hardcoded seed: %s\n", addr.ToString());
         vSeedsOut.push_back(addr);
     }
     return vSeedsOut;
@@ -2258,7 +2259,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
                 LogPrintf("Adding fixed seed nodes as DNS doesn't seem to be available.\n");
                 CNetAddr local;
                 local.SetInternal("fixedseeds");
-                addrman.Add(convertSeed6(Params().FixedSeeds()), local);
+                addrman.Add(ConvertSeeds(Params().FixedSeeds()), local);
                 done = true;
             }
         }

From 546f7557d86767e4995ed4c50c3396a148b2dae3 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 13 Sep 2020 11:04:50 +0200
Subject: [PATCH 09/21] merge bitcoin#19951: CNetAddr scoped ipv6 test
 coverage, rename scopeId to m_scope_id

---
 src/netaddress.cpp     |  4 ++--
 src/netaddress.h       |  8 ++++++--
 src/test/net_tests.cpp | 19 +++++++++++++++++++
 3 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/netaddress.cpp b/src/netaddress.cpp
index b571ee4306fdf..17eee364e459d 100644
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -323,7 +323,7 @@ CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
 CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr, const uint32_t scope)
 {
     SetLegacyIPv6(Span<const uint8_t>(reinterpret_cast<const uint8_t*>(&ipv6Addr), sizeof(ipv6Addr)));
-    scopeId = scope;
+    m_scope_id = scope;
 }
 
 bool CNetAddr::IsBindAny() const
@@ -1002,7 +1002,7 @@ bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
         memset(paddrin6, 0, *addrlen);
         if (!GetIn6Addr(&paddrin6->sin6_addr))
             return false;
-        paddrin6->sin6_scope_id = scopeId;
+        paddrin6->sin6_scope_id = m_scope_id;
         paddrin6->sin6_family = AF_INET6;
         paddrin6->sin6_port = htons(port);
         return true;
diff --git a/src/netaddress.h b/src/netaddress.h
index 49800a9085c8a..cf9c8ab70c522 100644
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -134,7 +134,11 @@ class CNetAddr
          */
         Network m_net{NET_IPV6};
 
-        uint32_t scopeId{0}; // for scoped/link-local ipv6 addresses
+        /**
+         * Scope id if scoped/link-local IPV6 address.
+         * See https://tools.ietf.org/html/rfc4007
+         */
+        uint32_t m_scope_id{0};
 
     public:
         CNetAddr();
@@ -433,7 +437,7 @@ class CNetAddr
                     "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
             }
 
-            scopeId = 0;
+            m_scope_id = 0;
 
             if (SetNetFromBIP155Network(bip155_net, address_size)) {
                 m_addr.resize(address_size);
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 0b7db7bc1782c..f0cbfc13583cb 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -262,6 +262,25 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
     BOOST_CHECK(addr.IsAddrV1Compatible());
     BOOST_CHECK_EQUAL(addr.ToString(), "1122:3344:5566:7788:9900:aabb:ccdd:eeff");
 
+    // IPv6, scoped/link-local. See https://tools.ietf.org/html/rfc4007
+    // We support non-negative decimal integers (uint32_t) as zone id indices.
+    // Test with a fairly-high value, e.g. 32, to avoid locally reserved ids.
+    const std::string link_local{"fe80::1"};
+    const std::string scoped_addr{link_local + "%32"};
+    BOOST_REQUIRE(LookupHost(scoped_addr, addr, false));
+    BOOST_REQUIRE(addr.IsValid());
+    BOOST_REQUIRE(addr.IsIPv6());
+    BOOST_CHECK(!addr.IsBindAny());
+    const std::string addr_str{addr.ToString()};
+    BOOST_CHECK(addr_str == scoped_addr || addr_str == "fe80:0:0:0:0:0:0:1");
+    // The fallback case "fe80:0:0:0:0:0:0:1" is needed for macOS 10.14/10.15 and (probably) later.
+    // Test that the delimiter "%" and default zone id of 0 can be omitted for the default scope.
+    BOOST_REQUIRE(LookupHost(link_local + "%0", addr, false));
+    BOOST_REQUIRE(addr.IsValid());
+    BOOST_REQUIRE(addr.IsIPv6());
+    BOOST_CHECK(!addr.IsBindAny());
+    BOOST_CHECK_EQUAL(addr.ToString(), link_local);
+
     // TORv2
     BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
     BOOST_REQUIRE(addr.IsValid());

From 5d7367e366b45f1af866bffbc8e28d5439d83d02 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 20 Sep 2023 16:31:53 +0530
Subject: [PATCH 10/21] merge bitcoin#22050: remove tor v2 support

---
 contrib/seeds/generate-seeds.py  | 17 +++++---
 src/netaddress.cpp               | 67 ++++++++++----------------------
 src/netaddress.h                 | 21 ++--------
 src/test/fuzz/deserialize.cpp    |  6 +--
 src/test/net_tests.cpp           | 39 ++++---------------
 src/test/netbase_tests.cpp       | 36 ++++++-----------
 test/functional/feature_proxy.py |  4 +-
 7 files changed, 60 insertions(+), 130 deletions(-)

diff --git a/contrib/seeds/generate-seeds.py b/contrib/seeds/generate-seeds.py
index fb714d61a57ef..75cb6fad6e80c 100755
--- a/contrib/seeds/generate-seeds.py
+++ b/contrib/seeds/generate-seeds.py
@@ -36,7 +36,7 @@
 class BIP155Network(Enum):
     IPV4 = 1
     IPV6 = 2
-    TORV2 = 3
+    TORV2 = 3  # no longer supported
     TORV3 = 4
     I2P = 5
     CJDNS = 6
@@ -45,11 +45,11 @@ def name_to_bip155(addr):
     '''Convert address string to BIP155 (networkID, addr) tuple.'''
     if addr.endswith('.onion'):
         vchAddr = b32decode(addr[0:-6], True)
-        if len(vchAddr) == 10:
-            return (BIP155Network.TORV2, vchAddr)
-        elif len(vchAddr) == 35:
-            assert(vchAddr[34] == 3)
+        if len(vchAddr) == 35:
+            assert vchAddr[34] == 3
             return (BIP155Network.TORV3, vchAddr[:32])
+        elif len(vchAddr) == 10:
+            return (BIP155Network.TORV2, vchAddr)
         else:
             raise ValueError('Invalid onion %s' % vchAddr)
     elif '.' in addr: # IPv4
@@ -93,7 +93,10 @@ def parse_spec(s):
 
     host = name_to_bip155(host)
 
-    return host + (port, )
+    if host[0] == BIP155Network.TORV2:
+        return None  # TORV2 is no longer supported, so we ignore it
+    else:
+        return host + (port, )
 
 def ser_compact_size(l):
     r = b""
@@ -129,6 +132,8 @@ def process_nodes(g, f, structname):
             continue
 
         spec = parse_spec(line)
+        if spec is None:  # ignore this entry (e.g. no longer supported addresses like TORV2)
+            continue
         blob = bip155_serialize(spec)
         hoststr = ','.join(('0x%02x' % b) for b in blob)
         g.write(f'    {hoststr},\n')
diff --git a/src/netaddress.cpp b/src/netaddress.cpp
index 17eee364e459d..f94631d08767d 100644
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -31,14 +31,7 @@ CNetAddr::BIP155Network CNetAddr::GetBIP155Network() const
     case NET_IPV6:
         return BIP155Network::IPV6;
     case NET_ONION:
-        switch (m_addr.size()) {
-        case ADDR_TORV2_SIZE:
-            return BIP155Network::TORV2;
-        case ADDR_TORV3_SIZE:
-            return BIP155Network::TORV3;
-        default:
-            assert(false);
-        }
+        return BIP155Network::TORV3;
     case NET_I2P:
         return BIP155Network::I2P;
     case NET_CJDNS:
@@ -71,14 +64,6 @@ bool CNetAddr::SetNetFromBIP155Network(uint8_t possible_bip155_net, size_t addre
         throw std::ios_base::failure(
             strprintf("BIP155 IPv6 address with length %u (should be %u)", address_size,
                       ADDR_IPV6_SIZE));
-    case BIP155Network::TORV2:
-        if (address_size == ADDR_TORV2_SIZE) {
-            m_net = NET_ONION;
-            return true;
-        }
-        throw std::ios_base::failure(
-            strprintf("BIP155 TORv2 address with length %u (should be %u)", address_size,
-                      ADDR_TORV2_SIZE));
     case BIP155Network::TORV3:
         if (address_size == ADDR_TORV3_SIZE) {
             m_net = NET_ONION;
@@ -131,7 +116,7 @@ void CNetAddr::SetIP(const CNetAddr& ipIn)
         assert(ipIn.m_addr.size() == ADDR_IPV6_SIZE);
         break;
     case NET_ONION:
-        assert(ipIn.m_addr.size() == ADDR_TORV2_SIZE || ipIn.m_addr.size() == ADDR_TORV3_SIZE);
+        assert(ipIn.m_addr.size() == ADDR_TORV3_SIZE);
         break;
     case NET_I2P:
         assert(ipIn.m_addr.size() == ADDR_I2P_SIZE);
@@ -162,9 +147,12 @@ void CNetAddr::SetLegacyIPv6(Span<const uint8_t> ipv6)
         m_net = NET_IPV4;
         skip = sizeof(IPV4_IN_IPV6_PREFIX);
     } else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
-        // TORv2-in-IPv6
-        m_net = NET_ONION;
-        skip = sizeof(TORV2_IN_IPV6_PREFIX);
+        // TORv2-in-IPv6 (unsupported). Unserialize as !IsValid(), thus ignoring them.
+        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
+        // will not be gossiped, but continue reading next addresses from the stream.
+        m_net = NET_IPV6;
+        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
+        return;
     } else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
         // Internal-in-IPv6
         m_net = NET_INTERNAL;
@@ -255,12 +243,7 @@ bool CNetAddr::SetTor(const std::string& addr)
         return false;
     }
 
-    switch (input.size()) {
-    case ADDR_TORV2_SIZE:
-        m_net = NET_ONION;
-        m_addr.assign(input.begin(), input.end());
-        return true;
-    case torv3::TOTAL_LEN: {
+    if (input.size() == torv3::TOTAL_LEN) {
         Span<const uint8_t> input_pubkey{input.data(), ADDR_TORV3_SIZE};
         Span<const uint8_t> input_checksum{input.data() + ADDR_TORV3_SIZE, torv3::CHECKSUM_LEN};
         Span<const uint8_t> input_version{input.data() + ADDR_TORV3_SIZE + torv3::CHECKSUM_LEN, sizeof(torv3::VERSION)};
@@ -280,7 +263,6 @@ bool CNetAddr::SetTor(const std::string& addr)
         m_addr.assign(input_pubkey.begin(), input_pubkey.end());
         return true;
     }
-    }
 
     return false;
 }
@@ -533,7 +515,6 @@ bool CNetAddr::IsAddrV1Compatible() const
     case NET_INTERNAL:
         return true;
     case NET_ONION:
-        return m_addr.size() == ADDR_TORV2_SIZE;
     case NET_I2P:
     case NET_CJDNS:
         return false;
@@ -577,6 +558,17 @@ static std::string IPv6ToString(Span<const uint8_t> a)
     // clang-format on
 }
 
+static std::string OnionToString(const Span<const uint8_t>& addr)
+{
+    uint8_t checksum[torv3::CHECKSUM_LEN];
+    torv3::Checksum(addr, checksum);
+    // TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION) + ".onion"
+    prevector<torv3::TOTAL_LEN, uint8_t> address{addr.begin(), addr.end()};
+    address.insert(address.end(), checksum, checksum + torv3::CHECKSUM_LEN);
+    address.insert(address.end(), torv3::VERSION, torv3::VERSION + sizeof(torv3::VERSION));
+    return EncodeBase32(address) + ".onion";
+}
+
 std::string CNetAddr::ToStringIP(bool fUseGetnameinfo) const
 {
     switch (m_net) {
@@ -597,24 +589,7 @@ std::string CNetAddr::ToStringIP(bool fUseGetnameinfo) const
         return IPv6ToString(m_addr);
     }
     case NET_ONION:
-        switch (m_addr.size()) {
-        case ADDR_TORV2_SIZE:
-            return EncodeBase32(m_addr) + ".onion";
-        case ADDR_TORV3_SIZE: {
-
-            uint8_t checksum[torv3::CHECKSUM_LEN];
-            torv3::Checksum(m_addr, checksum);
-
-            // TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION) + ".onion"
-            prevector<torv3::TOTAL_LEN, uint8_t> address{m_addr.begin(), m_addr.end()};
-            address.insert(address.end(), checksum, checksum + torv3::CHECKSUM_LEN);
-            address.insert(address.end(), torv3::VERSION, torv3::VERSION + sizeof(torv3::VERSION));
-
-            return EncodeBase32(address) + ".onion";
-        }
-        default:
-            assert(false);
-        }
+        return OnionToString(m_addr);
     case NET_I2P:
         return EncodeBase32(m_addr, false /* don't pad with = */) + ".b32.i2p";
     case NET_CJDNS:
diff --git a/src/netaddress.h b/src/netaddress.h
index cf9c8ab70c522..a2b8418ad4e95 100644
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -98,9 +98,6 @@ static constexpr size_t ADDR_IPV4_SIZE = 4;
 /// Size of IPv6 address (in bytes).
 static constexpr size_t ADDR_IPV6_SIZE = 16;
 
-/// Size of TORv2 address (in bytes).
-static constexpr size_t ADDR_TORV2_SIZE = 10;
-
 /// Size of TORv3 address (in bytes). This is the length of just the address
 /// as used in BIP155, without the checksum and the version byte.
 static constexpr size_t ADDR_TORV3_SIZE = 32;
@@ -262,8 +259,7 @@ class CNetAddr
         /**
          * Parse a Tor address and set this object to it.
          * @param[in] addr Address to parse, must be a valid C string, for example
-         * pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion or
-         * 6hzph5hv6337r6p2.onion.
+         * pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.
          * @returns Whether the operation was successful.
          * @see CNetAddr::IsTor()
          */
@@ -305,7 +301,7 @@ class CNetAddr
         /**
          * Get the BIP155 network id of this address.
          * Must not be called for IsInternal() objects.
-         * @returns BIP155 network id
+         * @returns BIP155 network id, except TORV2 which is no longer supported.
          */
         BIP155Network GetBIP155Network() const;
 
@@ -336,23 +332,14 @@ class CNetAddr
                 memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
                 memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
                 return;
-            case NET_ONION:
-                if (m_addr.size() == ADDR_TORV3_SIZE) {
-                    break;
-                }
-                prefix_size = sizeof(TORV2_IN_IPV6_PREFIX);
-                assert(prefix_size + m_addr.size() == sizeof(arr));
-                memcpy(arr, TORV2_IN_IPV6_PREFIX.data(), prefix_size);
-                memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
-                return;
             case NET_INTERNAL:
                 prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
                 assert(prefix_size + m_addr.size() == sizeof(arr));
                 memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
                 memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
                 return;
+            case NET_ONION:
             case NET_I2P:
-                break;
             case NET_CJDNS:
                 break;
             case NET_UNROUTABLE:
@@ -360,7 +347,7 @@ class CNetAddr
                 assert(false);
             } // no default case, so the compiler can warn about missing cases
 
-            // Serialize TORv3, I2P and CJDNS as all-zeros.
+            // Serialize ONION, I2P and CJDNS as all-zeros.
             memset(arr, 0x0, V1_SERIALIZATION_SIZE);
         }
 
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index 09cbb1644bd84..fb0a9127c8c7c 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -145,7 +145,7 @@ FUZZ_TARGET_DESERIALIZE(script_deserialize, {
         CScript script;
         DeserializeFromFuzzingInput(buffer, script);
 })
-FUZZ_TARGET_DESERIALIZE(sub_net_deserialize, {
+FUZZ_TARGET_DESERIALIZE(subnet_deserialize, {
         CSubNet sub_net_1;
         DeserializeFromFuzzingInput(buffer, sub_net_1, INIT_PROTO_VERSION);
         AssertEqualAfterSerializeDeserialize(sub_net_1, INIT_PROTO_VERSION);
@@ -227,7 +227,7 @@ FUZZ_TARGET_DESERIALIZE(coins_deserialize, {
         Coin coin;
         DeserializeFromFuzzingInput(buffer, coin);
 })
-FUZZ_TARGET_DESERIALIZE(netaddr_deserialize, {
+FUZZ_TARGET_DESERIALIZE(net_address_deserialize, {
         CNetAddr na;
         DeserializeFromFuzzingInput(buffer, na);
         if (na.IsAddrV1Compatible()) {
@@ -235,7 +235,7 @@ FUZZ_TARGET_DESERIALIZE(netaddr_deserialize, {
         }
         AssertEqualAfterSerializeDeserialize(na, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
-FUZZ_TARGET_DESERIALIZE(service_deserialize, {
+FUZZ_TARGET_DESERIALIZE(net_service_deserialize, {
         CService s;
         DeserializeFromFuzzingInput(buffer, s);
         if (s.IsAddrV1Compatible()) {
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index f0cbfc13583cb..4933f948fd0c1 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -281,15 +281,8 @@ BOOST_AUTO_TEST_CASE(cnetaddr_basic)
     BOOST_CHECK(!addr.IsBindAny());
     BOOST_CHECK_EQUAL(addr.ToString(), link_local);
 
-    // TORv2
-    BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
-    BOOST_REQUIRE(addr.IsValid());
-    BOOST_REQUIRE(addr.IsTor());
-
-    BOOST_CHECK(!addr.IsI2P());
-    BOOST_CHECK(!addr.IsBindAny());
-    BOOST_CHECK(addr.IsAddrV1Compatible());
-    BOOST_CHECK_EQUAL(addr.ToString(), "6hzph5hv6337r6p2.onion");
+    // TORv2, no longer supported
+    BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion"));
 
     // TORv3
     const char* torv3_addr = "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion";
@@ -379,10 +372,8 @@ BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v1)
     BOOST_CHECK_EQUAL(HexStr(s), "1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
     s.clear();
 
-    BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
-    s << addr;
-    BOOST_CHECK_EQUAL(HexStr(s), "fd87d87eeb43f1f2f3f4f5f6f7f8f9fa");
-    s.clear();
+    // TORv2, no longer supported
+    BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion"));
 
     BOOST_REQUIRE(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
     s << addr;
@@ -417,10 +408,8 @@ BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v2)
     BOOST_CHECK_EQUAL(HexStr(s), "02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
     s.clear();
 
-    BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
-    s << addr;
-    BOOST_CHECK_EQUAL(HexStr(s), "030af1f2f3f4f5f6f7f8f9fa");
-    s.clear();
+    // TORv2, no longer supported
+    BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion"));
 
     BOOST_REQUIRE(addr.SetSpecial("kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion"));
     s << addr;
@@ -526,26 +515,14 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
-    // Valid TORv2.
+    // TORv2, no longer supported.
     s << MakeSpan(ParseHex("03"                      // network type (TORv2)
                            "0a"                      // address length
                            "f1f2f3f4f5f6f7f8f9fa")); // address
     s >> addr;
-    BOOST_CHECK(addr.IsValid());
-    BOOST_CHECK(addr.IsTor());
-    BOOST_CHECK(addr.IsAddrV1Compatible());
-    BOOST_CHECK_EQUAL(addr.ToString(), "6hzph5hv6337r6p2.onion");
+    BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
-    // Invalid TORv2, with bogus length.
-    s << MakeSpan(ParseHex("03"    // network type (TORv2)
-                           "07"    // address length
-                           "00")); // address
-    BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
-                          HasReason("BIP155 TORv2 address with length 7 (should be 10)"));
-    BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
-    s.clear();
-
     // Valid TORv3.
     s << MakeSpan(ParseHex("04"                               // network type (TORv3)
                            "20"                               // address length
diff --git a/src/test/netbase_tests.cpp b/src/test/netbase_tests.cpp
index 30a46c0e05561..fcb11b7a0bba7 100644
--- a/src/test/netbase_tests.cpp
+++ b/src/test/netbase_tests.cpp
@@ -45,13 +45,12 @@ static CNetAddr CreateInternal(const std::string& host)
 
 BOOST_AUTO_TEST_CASE(netbase_networks)
 {
-    BOOST_CHECK(ResolveIP("127.0.0.1").GetNetwork()                              == NET_UNROUTABLE);
-    BOOST_CHECK(ResolveIP("::1").GetNetwork()                                    == NET_UNROUTABLE);
-    BOOST_CHECK(ResolveIP("8.8.8.8").GetNetwork()                                == NET_IPV4);
-    BOOST_CHECK(ResolveIP("2001::8888").GetNetwork()                             == NET_IPV6);
-    BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetNetwork() == NET_ONION);
-    BOOST_CHECK(CreateInternal("foo.com").GetNetwork()                           == NET_INTERNAL);
-
+    BOOST_CHECK(ResolveIP("127.0.0.1").GetNetwork() == NET_UNROUTABLE);
+    BOOST_CHECK(ResolveIP("::1").GetNetwork() == NET_UNROUTABLE);
+    BOOST_CHECK(ResolveIP("8.8.8.8").GetNetwork() == NET_IPV4);
+    BOOST_CHECK(ResolveIP("2001::8888").GetNetwork() == NET_IPV6);
+    BOOST_CHECK(ResolveIP("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion").GetNetwork() == NET_ONION);
+    BOOST_CHECK(CreateInternal("foo.com").GetNetwork() == NET_INTERNAL);
 }
 
 BOOST_AUTO_TEST_CASE(netbase_properties)
@@ -74,7 +73,7 @@ BOOST_AUTO_TEST_CASE(netbase_properties)
     BOOST_CHECK(ResolveIP("2001:20::").IsRFC7343());
     BOOST_CHECK(ResolveIP("FE80::").IsRFC4862());
     BOOST_CHECK(ResolveIP("64:FF9B::").IsRFC6052());
-    BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").IsTor());
+    BOOST_CHECK(ResolveIP("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion").IsTor());
     BOOST_CHECK(ResolveIP("127.0.0.1").IsLocal());
     BOOST_CHECK(ResolveIP("::1").IsLocal());
     BOOST_CHECK(ResolveIP("8.8.8.8").IsRoutable());
@@ -134,18 +133,6 @@ BOOST_AUTO_TEST_CASE(netbase_lookupnumeric)
     BOOST_CHECK(TestParse("[fd6c:88c0:8724:1:2:3:4:5]", "[fd6c:88c0:8724:1:2:3:4:5]:65535"));
 }
 
-BOOST_AUTO_TEST_CASE(onioncat_test)
-{
-    // values from https://web.archive.org/web/20121122003543/http://www.cypherpunk.at/onioncat/wiki/OnionCat
-    CNetAddr addr1(ResolveIP("5wyqrzbvrdsumnok.onion"));
-    CNetAddr addr2(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca"));
-    BOOST_CHECK(addr1 == addr2);
-    BOOST_CHECK(addr1.IsTor());
-    BOOST_CHECK(addr1.ToStringIP() == "5wyqrzbvrdsumnok.onion");
-    BOOST_CHECK(addr1.IsRoutable());
-
-}
-
 BOOST_AUTO_TEST_CASE(embedded_test)
 {
     CNetAddr addr1(ResolveIP("1.2.3.4"));
@@ -339,7 +326,6 @@ BOOST_AUTO_TEST_CASE(netbase_getgroup)
     BOOST_CHECK(ResolveIP("64:FF9B::102:304").GetGroup(asmap) == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC6052
     BOOST_CHECK(ResolveIP("2002:102:304:9999:9999:9999:9999:9999").GetGroup(asmap) == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC3964
     BOOST_CHECK(ResolveIP("2001:0:9999:9999:9999:9999:FEFD:FCFB").GetGroup(asmap) == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC4380
-    BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetGroup(asmap) == std::vector<unsigned char>({(unsigned char)NET_ONION, 239})); // Tor
     BOOST_CHECK(ResolveIP("2001:470:abcd:9999:9999:9999:9999:9999").GetGroup(asmap) == std::vector<unsigned char>({(unsigned char)NET_IPV6, 32, 1, 4, 112, 175})); //he.net
     BOOST_CHECK(ResolveIP("2001:2001:9999:9999:9999:9999:9999:9999").GetGroup(asmap) == std::vector<unsigned char>({(unsigned char)NET_IPV6, 32, 1, 32, 1})); //IPv6
 
@@ -559,10 +545,10 @@ BOOST_AUTO_TEST_CASE(netbase_dont_resolve_strings_with_embedded_nul_characters)
     BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0"s, ret));
     BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0example.com"s, ret));
     BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0example.com\0"s, ret));
-    BOOST_CHECK(LookupSubNet("5wyqrzbvrdsumnok.onion"s, ret));
-    BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0"s, ret));
-    BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0example.com"s, ret));
-    BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0example.com\0"s, ret));
+    BOOST_CHECK(LookupSubNet("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"s, ret));
+    BOOST_CHECK(!LookupSubNet("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion\0"s, ret));
+    BOOST_CHECK(!LookupSubNet("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion\0example.com"s, ret));
+    BOOST_CHECK(!LookupSubNet("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion\0example.com\0"s, ret));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_proxy.py b/test/functional/feature_proxy.py
index f55e2d65941bf..a32b032d5739f 100755
--- a/test/functional/feature_proxy.py
+++ b/test/functional/feature_proxy.py
@@ -147,13 +147,13 @@ def node_test(self, node, proxies, auth, test_onion=True):
             self.network_test(node, addr, network=NET_IPV6)
 
         if test_onion:
-            addr = "bitcoinostk4e4re.onion:8333"
+            addr = "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:8333"
             self.log.debug("Test: outgoing onion connection through node for address {}".format(addr))
             node.addnode(addr, "onetry")
             cmd = proxies[2].queue.get()
             assert isinstance(cmd, Socks5Command)
             assert_equal(cmd.atyp, AddressType.DOMAINNAME)
-            assert_equal(cmd.addr, b"bitcoinostk4e4re.onion")
+            assert_equal(cmd.addr, b"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion")
             assert_equal(cmd.port, 8333)
             if not auth:
                 assert_equal(cmd.username, None)

From 8c2d480f1ab02a42739f3f880ad0f9382bfcf854 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sat, 9 Sep 2023 00:49:46 +0530
Subject: [PATCH 11/21] merge bitcoin#23115: use Span instead of std::vector
 for insert and contains

---
 src/bloom.cpp            | 69 ++++++++++++----------------------------
 src/bloom.h              | 21 +++++-------
 src/hash.cpp             |  1 +
 src/test/bloom_tests.cpp |  2 +-
 4 files changed, 31 insertions(+), 62 deletions(-)

diff --git a/src/bloom.cpp b/src/bloom.cpp
index b9508b3da1246..1bb8cff7d8cf9 100644
--- a/src/bloom.cpp
+++ b/src/bloom.cpp
@@ -4,23 +4,27 @@
 
 #include <bloom.h>
 
-#include <primitives/transaction.h>
 #include <evo/assetlocktx.h>
-#include <evo/specialtx.h>
 #include <evo/providertx.h>
-#include <logging.h>
+#include <evo/specialtx.h>
 #include <hash.h>
+#include <logging.h>
+#include <primitives/transaction.h>
+#include <random.h>
 #include <script/script.h>
 #include <script/standard.h>
-#include <random.h>
+#include <span.h>
 #include <streams.h>
 #include <util/fastrange.h>
 
-#include <math.h>
-#include <stdlib.h>
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <vector>
 
-#define LN2SQUARED 0.4804530139182014246671025263266649717305529515945455
-#define LN2 0.6931471805599453094172321214581765680755001343602552
+static constexpr double LN2SQUARED = 0.4804530139182014246671025263266649717305529515945455;
+static constexpr double LN2 = 0.6931471805599453094172321214581765680755001343602552;
 
 CBloomFilter::CBloomFilter(const unsigned int nElements, const double nFPRate, const unsigned int nTweakIn, unsigned char nFlagsIn) :
     /**
@@ -40,13 +44,13 @@ CBloomFilter::CBloomFilter(const unsigned int nElements, const double nFPRate, c
 {
 }
 
-inline unsigned int CBloomFilter::Hash(unsigned int nHashNum, const std::vector<unsigned char>& vDataToHash) const
+inline unsigned int CBloomFilter::Hash(unsigned int nHashNum, Span<const unsigned char> vDataToHash) const
 {
     // 0xFBA4C795 chosen as it guarantees a reasonable bit difference between nHashNum values.
     return MurmurHash3(nHashNum * 0xFBA4C795 + nTweak, vDataToHash) % (vData.size() * 8);
 }
 
-void CBloomFilter::insert(const std::vector<unsigned char>& vKey)
+void CBloomFilter::insert(Span<const unsigned char> vKey)
 {
     if (vData.empty()) // Avoid divide-by-zero (CVE-2013-5700)
         return;
@@ -62,17 +66,10 @@ void CBloomFilter::insert(const COutPoint& outpoint)
 {
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << outpoint;
-    std::vector<unsigned char> data(stream.begin(), stream.end());
-    insert(data);
-}
-
-void CBloomFilter::insert(const uint256& hash)
-{
-    std::vector<unsigned char> data(hash.begin(), hash.end());
-    insert(data);
+    insert(stream);
 }
 
-bool CBloomFilter::contains(const std::vector<unsigned char>& vKey) const
+bool CBloomFilter::contains(Span<const unsigned char> vKey) const
 {
     if (vData.empty()) // Avoid divide-by-zero (CVE-2013-5700)
         return true;
@@ -90,20 +87,7 @@ bool CBloomFilter::contains(const COutPoint& outpoint) const
 {
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << outpoint;
-    std::vector<unsigned char> data(stream.begin(), stream.end());
-    return contains(data);
-}
-
-bool CBloomFilter::contains(const uint256& hash) const
-{
-    std::vector<unsigned char> data(hash.begin(), hash.end());
-    return contains(data);
-}
-
-bool CBloomFilter::contains(const uint160& hash) const
-{
-    std::vector<unsigned char> data(hash.begin(), hash.end());
-    return contains(data);
+    return contains(MakeUCharSpan(stream));
 }
 
 bool CBloomFilter::IsWithinSizeConstraints() const
@@ -304,11 +288,12 @@ CRollingBloomFilter::CRollingBloomFilter(const unsigned int nElements, const dou
 }
 
 /* Similar to CBloomFilter::Hash */
-static inline uint32_t RollingBloomHash(unsigned int nHashNum, uint32_t nTweak, const std::vector<unsigned char>& vDataToHash) {
+static inline uint32_t RollingBloomHash(unsigned int nHashNum, uint32_t nTweak, Span<const unsigned char> vDataToHash)
+{
     return MurmurHash3(nHashNum * 0xFBA4C795 + nTweak, vDataToHash);
 }
 
-void CRollingBloomFilter::insert(const std::vector<unsigned char>& vKey)
+void CRollingBloomFilter::insert(Span<const unsigned char> vKey)
 {
     if (nEntriesThisGeneration == nEntriesPerGeneration) {
         nEntriesThisGeneration = 0;
@@ -339,13 +324,7 @@ void CRollingBloomFilter::insert(const std::vector<unsigned char>& vKey)
     }
 }
 
-void CRollingBloomFilter::insert(const uint256& hash)
-{
-    std::vector<unsigned char> vData(hash.begin(), hash.end());
-    insert(vData);
-}
-
-bool CRollingBloomFilter::contains(const std::vector<unsigned char>& vKey) const
+bool CRollingBloomFilter::contains(Span<const unsigned char> vKey) const
 {
     for (int n = 0; n < nHashFuncs; n++) {
         uint32_t h = RollingBloomHash(n, nTweak, vKey);
@@ -359,12 +338,6 @@ bool CRollingBloomFilter::contains(const std::vector<unsigned char>& vKey) const
     return true;
 }
 
-bool CRollingBloomFilter::contains(const uint256& hash) const
-{
-    std::vector<unsigned char> vData(hash.begin(), hash.end());
-    return contains(vData);
-}
-
 void CRollingBloomFilter::reset()
 {
     nTweak = GetRand(std::numeric_limits<unsigned int>::max());
diff --git a/src/bloom.h b/src/bloom.h
index e2ecbbaef1cdc..1d3a9ac3e1b06 100644
--- a/src/bloom.h
+++ b/src/bloom.h
@@ -6,6 +6,7 @@
 #define BITCOIN_BLOOM_H
 
 #include <serialize.h>
+#include <span.h>
 
 #include <vector>
 
@@ -14,11 +15,10 @@ class CScript;
 class CTransaction;
 class CTxOut;
 class uint256;
-class uint160;
 
 //! 20,000 items with fp rate < 0.1% or 10,000 items and <0.0001%
-static const unsigned int MAX_BLOOM_FILTER_SIZE = 36000; // bytes
-static const unsigned int MAX_HASH_FUNCS = 50;
+static constexpr unsigned int MAX_BLOOM_FILTER_SIZE = 36000; // bytes
+static constexpr unsigned int MAX_HASH_FUNCS = 50;
 
 /**
  * First two bits of nFlags control how much IsRelevantAndUpdate actually updates
@@ -52,7 +52,7 @@ class CBloomFilter
     unsigned int nTweak;
     unsigned char nFlags;
 
-    unsigned int Hash(unsigned int nHashNum, const std::vector<unsigned char>& vDataToHash) const;
+    unsigned int Hash(unsigned int nHashNum, Span<const unsigned char> vDataToHash) const;
 
     // Check matches for arbitrary script data elements
     bool CheckScript(const CScript& script) const;
@@ -75,14 +75,11 @@ class CBloomFilter
 
     SERIALIZE_METHODS(CBloomFilter, obj) { READWRITE(obj.vData, obj.nHashFuncs, obj.nTweak, obj.nFlags); }
 
-    void insert(const std::vector<unsigned char>& vKey);
+    void insert(Span<const unsigned char> vKey);
     void insert(const COutPoint& outpoint);
-    void insert(const uint256& hash);
 
-    bool contains(const std::vector<unsigned char>& vKey) const;
+    bool contains(Span<const unsigned char> vKey) const;
     bool contains(const COutPoint& outpoint) const;
-    bool contains(const uint256& hash) const;
-    bool contains(const uint160& hash) const;
 
     //! True if the size is <= MAX_BLOOM_FILTER_SIZE and the number of hash functions is <= MAX_HASH_FUNCS
     //! (catch a filter which was just deserialized which was too big)
@@ -122,10 +119,8 @@ class CRollingBloomFilter
 public:
     CRollingBloomFilter(const unsigned int nElements, const double nFPRate);
 
-    void insert(const std::vector<unsigned char>& vKey);
-    void insert(const uint256& hash);
-    bool contains(const std::vector<unsigned char>& vKey) const;
-    bool contains(const uint256& hash) const;
+    void insert(Span<const unsigned char> vKey);
+    bool contains(Span<const unsigned char> vKey) const;
 
     void reset();
 
diff --git a/src/hash.cpp b/src/hash.cpp
index 89491ad9f36ae..2b2d228284f12 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <hash.h>
+#include <span.h>
 #include <crypto/common.h>
 #include <crypto/hmac_sha512.h>
 
diff --git a/src/test/bloom_tests.cpp b/src/test/bloom_tests.cpp
index d15632893dc65..2d8df16583436 100644
--- a/src/test/bloom_tests.cpp
+++ b/src/test/bloom_tests.cpp
@@ -81,7 +81,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
     CBloomFilter filter(2, 0.001, 0, BLOOM_UPDATE_ALL);
     filter.insert(vchPubKey);
     uint160 hash = pubkey.GetID();
-    filter.insert(std::vector<unsigned char>(hash.begin(), hash.end()));
+    filter.insert(hash);
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;

From de54b8784ca59e5c98cec4ac3b84075adcb22f63 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 2 Jan 2022 11:19:01 +0100
Subject: [PATCH 12/21] partial bitcoin#23438: Use spans of std::byte in
 serialize

includes:
- fa65bbf217b725ada35107b4ad646d250228355c
---
 src/span.h | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/span.h b/src/span.h
index 3d96269768afd..b4bf6325dc041 100644
--- a/src/span.h
+++ b/src/span.h
@@ -237,16 +237,21 @@ T& SpanPopBack(Span<T>& span)
     return back;
 }
 
+//! Convert a data pointer to a std::byte data pointer.
+//! Where possible, please use the safer AsBytes helpers.
+inline const std::byte* BytePtr(const void* data) { return reinterpret_cast<const std::byte*>(data); }
+inline std::byte* BytePtr(void* data) { return reinterpret_cast<std::byte*>(data); }
+
 // From C++20 as_bytes and as_writeable_bytes
 template <typename T>
 Span<const std::byte> AsBytes(Span<T> s) noexcept
 {
-    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
+    return {BytePtr(s.data()), s.size_bytes()};
 }
 template <typename T>
 Span<std::byte> AsWritableBytes(Span<T> s) noexcept
 {
-    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
+    return {BytePtr(s.data()), s.size_bytes()};
 }
 
 template <typename V>

From 984f58d4df270b00b97346955e90a46f0a705fd6 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 1 Nov 2021 13:59:15 +0100
Subject: [PATCH 13/21] merge bitcoin#23409: Take Span in SetSeed

---
 src/hdchain.cpp                | 4 ++--
 src/key.cpp                    | 5 +++--
 src/key.h                      | 3 ++-
 src/test/bip32_tests.cpp       | 2 +-
 src/test/bip39_tests.cpp       | 2 +-
 src/test/key_io_tests.cpp      | 2 +-
 src/wallet/rpcdump.cpp         | 2 +-
 src/wallet/scriptpubkeyman.cpp | 2 +-
 8 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/hdchain.cpp b/src/hdchain.cpp
index 43e7b397fe1a7..811d8d2f7382d 100644
--- a/src/hdchain.cpp
+++ b/src/hdchain.cpp
@@ -55,7 +55,7 @@ void CHDChain::Debug(const std::string& strName) const
             std::cout << "seed: " << HexStr(vchSeed).c_str() << std::endl;
 
             CExtKey extkey;
-            extkey.SetSeed(vchSeed.data(), vchSeed.size());
+            extkey.SetSeed(vchSeed);
 
             std::cout << "extended private masterkey: " << EncodeExtKey(extkey).c_str() << std::endl;
 
@@ -167,7 +167,7 @@ void CHDChain::DeriveChildExtKey(uint32_t nAccountIndex, bool fInternal, uint32_
     CExtKey changeKey;              //key at m/purpose'/coin_type'/account'/change
     CExtKey childKey;               //key at m/purpose'/coin_type'/account'/change/address_index
 
-    masterKey.SetSeed(vchSeed.data(), vchSeed.size());
+    masterKey.SetSeed(vchSeed);
 
     // Use hardened derivation for purpose, coin_type and account
     // (keys >= 0x80000000 are hardened after bip32)
diff --git a/src/key.cpp b/src/key.cpp
index 04959dc74a298..f97de1e8d9f4f 100644
--- a/src/key.cpp
+++ b/src/key.cpp
@@ -298,10 +298,11 @@ bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
     return key.Derive(out.key, out.chaincode, _nChild, chaincode);
 }
 
-void CExtKey::SetSeed(const unsigned char *seed, unsigned int nSeedLen) {
+void CExtKey::SetSeed(Span<const uint8_t> seed)
+{
     static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
     std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
-    CHMAC_SHA512(hashkey, sizeof(hashkey)).Write(seed, nSeedLen).Finalize(vout.data());
+    CHMAC_SHA512{hashkey, sizeof(hashkey)}.Write(seed.data(), seed.size()).Finalize(vout.data());
     key.Set(vout.data(), vout.data() + 32, true);
     memcpy(chaincode.begin(), vout.data() + 32, 32);
     nDepth = 0;
diff --git a/src/key.h b/src/key.h
index f1b3099b2fdd4..802134c6d9a52 100644
--- a/src/key.h
+++ b/src/key.h
@@ -85,6 +85,7 @@ class CKey
 
     //! Simple read-only vector-like interface.
     unsigned int size() const { return (fValid ? keydata.size() : 0); }
+    const unsigned char* data() const { return keydata.data(); }
     const unsigned char* begin() const { return keydata.data(); }
     const unsigned char* end() const { return keydata.data() + size(); }
 
@@ -160,7 +161,7 @@ struct CExtKey {
     void Decode(const unsigned char code[BIP32_EXTKEY_SIZE]);
     bool Derive(CExtKey& out, unsigned int nChild) const;
     CExtPubKey Neuter() const;
-    void SetSeed(const unsigned char* seed, unsigned int nSeedLen);
+    void SetSeed(Span<const uint8_t> seed);
 };
 
 /** Initialize the elliptic curve support. May not be called twice without calling ECC_Stop first. */
diff --git a/src/test/bip32_tests.cpp b/src/test/bip32_tests.cpp
index 32329eb510625..00e3160048f05 100644
--- a/src/test/bip32_tests.cpp
+++ b/src/test/bip32_tests.cpp
@@ -91,7 +91,7 @@ static void RunTest(const TestVector &test) {
     std::vector<unsigned char> seed = ParseHex(test.strHexMaster);
     CExtKey key;
     CExtPubKey pubkey;
-    key.SetSeed(seed.data(), seed.size());
+    key.SetSeed(seed);
     pubkey = key.Neuter();
     for (const TestDerivation &derive : test.vDerive) {
         unsigned char data[74];
diff --git a/src/test/bip39_tests.cpp b/src/test/bip39_tests.cpp
index a26e98eace521..c35b00c4eafff 100644
--- a/src/test/bip39_tests.cpp
+++ b/src/test/bip39_tests.cpp
@@ -54,7 +54,7 @@ BOOST_AUTO_TEST_CASE(bip39_vectors)
         CExtKey key;
         CExtPubKey pubkey;
 
-        key.SetSeed(seed.data(), 64);
+        key.SetSeed(seed);
         pubkey = key.Neuter();
 
         // printf("CBitcoinExtKey: %s\n", EncodeExtKey(key).c_str());
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index f149b38b06a23..5d0ef030a3b63 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -47,7 +47,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
             privkey = DecodeSecret(exp_base58string);
             BOOST_CHECK_MESSAGE(privkey.IsValid(), "!IsValid:" + strTest);
             BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed, "compressed mismatch:" + strTest);
-            BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() && std::equal(privkey.begin(), privkey.end(), exp_payload.begin()), "key mismatch:" + strTest);
+            BOOST_CHECK_MESSAGE(Span<const uint8_t>{privkey} == Span<const uint8_t>{exp_payload}, "key mismatch:" + strTest);
 
             // Private key must be invalid public key
             destination = DecodeDestination(exp_base58string);
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 7dd486c71c46a..16246a25d6838 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -982,7 +982,7 @@ UniValue dumpwallet(const JSONRPCRequest& request)
         file << "# HD seed: " << HexStr(vchSeed) << "\n\n";
 
         CExtKey masterKey;
-        masterKey.SetSeed(&vchSeed[0], vchSeed.size());
+        masterKey.SetSeed(vchSeed);
 
         file << "# extended private masterkey: " << EncodeExtKey(masterKey) << "\n";
 
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 0a6f234e7bcad..7260aae0b733b 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -323,7 +323,7 @@ void LegacyScriptPubKeyMan::UpgradeKeyMetadata()
 
     CExtKey masterKey;
     SecureVector vchSeed = hdChainCurrent.GetSeed();
-    masterKey.SetSeed(vchSeed.data(), vchSeed.size());
+    masterKey.SetSeed(vchSeed);
     CKeyID master_id = masterKey.key.GetPubKey().GetID();
 
     std::unique_ptr<WalletBatch> batch = std::make_unique<WalletBatch>(m_storage.GetDatabase());

From 6b68cf82e11cf25f31615252d8a223edc3a0aca4 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sat, 9 Sep 2023 16:09:52 +0530
Subject: [PATCH 14/21] merge bitcoin#18468: Span improvements

includes:
- 2676aeadfa0e43dcaaccc4720623cdfe0beed528

completion of partial merge done in dash#4036 as ec2eec0c
---
 src/script/descriptor.cpp     |  6 +++---
 src/test/fuzz/span.cpp        |  4 ++--
 src/test/fuzz/spanparsing.cpp |  2 +-
 src/test/util_tests.cpp       | 22 +++++++++++-----------
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 1e519eaa6dcc9..2dc1fe810e46e 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -140,7 +140,7 @@ std::string DescriptorChecksum(const Span<const char>& span)
     return ret;
 }
 
-std::string AddChecksum(const std::string& str) { return str + "#" + DescriptorChecksum(MakeSpan(str)); }
+std::string AddChecksum(const std::string& str) { return str + "#" + DescriptorChecksum(str); }
 
 ////////////////////////////////////////////////////////////////////////////
 // Internal representation                                                //
@@ -1012,7 +1012,7 @@ bool CheckChecksum(Span<const char>& sp, bool require_checksum, std::string& err
 
 std::unique_ptr<Descriptor> Parse(const std::string& descriptor, FlatSigningProvider& out, std::string& error, bool require_checksum)
 {
-    Span<const char> sp(descriptor.data(), descriptor.size());
+    Span<const char> sp{descriptor};
     if (!CheckChecksum(sp, require_checksum, error)) return nullptr;
     auto ret = ParseScript(0, sp, ParseScriptContext::TOP, out, error);
     if (sp.size() == 0 && ret) return std::unique_ptr<Descriptor>(std::move(ret));
@@ -1023,7 +1023,7 @@ std::string GetDescriptorChecksum(const std::string& descriptor)
 {
     std::string ret;
     std::string error;
-    Span<const char> sp(descriptor.data(), descriptor.size());
+    Span<const char> sp{descriptor};
     if (!CheckChecksum(sp, false, error, &ret)) return "";
     return ret;
 }
diff --git a/src/test/fuzz/span.cpp b/src/test/fuzz/span.cpp
index 27ee07cadbfc9..8f753948df3d9 100644
--- a/src/test/fuzz/span.cpp
+++ b/src/test/fuzz/span.cpp
@@ -18,7 +18,7 @@ FUZZ_TARGET(span)
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
 
     std::string str = fuzzed_data_provider.ConsumeBytesAsString(32);
-    const Span<const char> span = MakeSpan(str);
+    const Span<const char> span{str};
     (void)span.data();
     (void)span.begin();
     (void)span.end();
@@ -32,7 +32,7 @@ FUZZ_TARGET(span)
     }
 
     std::string another_str = fuzzed_data_provider.ConsumeBytesAsString(32);
-    const Span<const char> another_span = MakeSpan(another_str);
+    const Span<const char> another_span{another_str};
     assert((span <= another_span) != (span > another_span));
     assert((span == another_span) != (span != another_span));
     assert((span >= another_span) != (span < another_span));
diff --git a/src/test/fuzz/spanparsing.cpp b/src/test/fuzz/spanparsing.cpp
index 06ed90e9c8532..293a7e7e902c0 100644
--- a/src/test/fuzz/spanparsing.cpp
+++ b/src/test/fuzz/spanparsing.cpp
@@ -12,7 +12,7 @@ FUZZ_TARGET(spanparsing)
     const size_t query_size = fuzzed_data_provider.ConsumeIntegral<size_t>();
     const std::string query = fuzzed_data_provider.ConsumeBytesAsString(std::min<size_t>(query_size, 1024 * 1024));
     const std::string span_str = fuzzed_data_provider.ConsumeRemainingBytesAsString();
-    const Span<const char> const_span = MakeSpan(span_str);
+    const Span<const char> const_span{span_str};
 
     Span<const char> mut_span = const_span;
     (void)spanparsing::Const(query, mut_span);
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index c1fe68c8706ba..b9a11454afabf 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -2308,7 +2308,7 @@ BOOST_AUTO_TEST_CASE(test_spanparsing)
 
     // Const(...): parse a constant, update span to skip it if successful
     input = "MilkToastHoney";
-    sp = MakeSpan(input);
+    sp = input;
     success = Const("", sp); // empty
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
@@ -2333,7 +2333,7 @@ BOOST_AUTO_TEST_CASE(test_spanparsing)
 
     // Func(...): parse a function call, update span to argument if successful
     input = "Foo(Bar(xy,z()))";
-    sp = MakeSpan(input);
+    sp = input;
 
     success = Func("FooBar", sp);
     BOOST_CHECK(!success);
@@ -2356,31 +2356,31 @@ BOOST_AUTO_TEST_CASE(test_spanparsing)
     Span<const char> result;
 
     input = "(n*(n-1))/2";
-    sp = MakeSpan(input);
+    sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "(n*(n-1))/2");
     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
 
     input = "foo,bar";
-    sp = MakeSpan(input);
+    sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "foo");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",bar");
 
     input = "(aaaaa,bbbbb()),c";
-    sp = MakeSpan(input);
+    sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "(aaaaa,bbbbb())");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",c");
 
     input = "xyz)foo";
-    sp = MakeSpan(input);
+    sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "xyz");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ")foo");
 
     input = "((a),(b),(c)),xxx";
-    sp = MakeSpan(input);
+    sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "((a),(b),(c))");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",xxx");
@@ -2389,7 +2389,7 @@ BOOST_AUTO_TEST_CASE(test_spanparsing)
     std::vector<Span<const char>> results;
 
     input = "xxx";
-    results = Split(MakeSpan(input), 'x');
+    results = Split(input, 'x');
     BOOST_CHECK_EQUAL(results.size(), 4);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "");
@@ -2397,19 +2397,19 @@ BOOST_AUTO_TEST_CASE(test_spanparsing)
     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
 
     input = "one#two#three";
-    results = Split(MakeSpan(input), '-');
+    results = Split(input, '-');
     BOOST_CHECK_EQUAL(results.size(), 1);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#two#three");
 
     input = "one#two#three";
-    results = Split(MakeSpan(input), '#');
+    results = Split(input, '#');
     BOOST_CHECK_EQUAL(results.size(), 3);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
 
     input = "*foo*bar*";
-    results = Split(MakeSpan(input), '*');
+    results = Split(input, '*');
     BOOST_CHECK_EQUAL(results.size(), 4);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo");

From 71f8c55d54308e87626878e522ec510705d25f00 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sat, 9 Sep 2023 16:18:47 +0530
Subject: [PATCH 15/21] merge bitcoin#19020: Use C++11 member initialization in
 protocol

---
 src/compat/assumptions.h |  1 +
 src/protocol.cpp         | 25 -------------------------
 src/protocol.h           | 20 +++++++++-----------
 3 files changed, 10 insertions(+), 36 deletions(-)

diff --git a/src/compat/assumptions.h b/src/compat/assumptions.h
index d61e186aafebc..f01662c31c509 100644
--- a/src/compat/assumptions.h
+++ b/src/compat/assumptions.h
@@ -46,6 +46,7 @@ static_assert(sizeof(double) == 8, "64-bit double assumed");
 //             code.
 static_assert(sizeof(short) == 2, "16-bit short assumed");
 static_assert(sizeof(int) == 4, "32-bit int assumed");
+static_assert(sizeof(unsigned) == 4, "32-bit unsigned assumed");
 
 // Assumption: We assume size_t to be 32-bit or 64-bit.
 // Example(s): size_t assumed to be at least 32-bit in ecdsa_signature_parse_der_lax(...).
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 3e3fd28cb40ed..c03db8e98f4a0 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -261,31 +261,6 @@ void SetServiceFlagsIBDCache(bool state) {
     g_initial_block_download_completed = state;
 }
 
-
-CAddress::CAddress() : CService()
-{
-    Init();
-}
-
-CAddress::CAddress(CService ipIn, ServiceFlags nServicesIn) : CService(ipIn)
-{
-    Init();
-    nServices = nServicesIn;
-}
-
-CAddress::CAddress(CService ipIn, ServiceFlags nServicesIn, uint32_t nTimeIn) : CService(ipIn)
-{
-    Init();
-    nServices = nServicesIn;
-    nTime = nTimeIn;
-}
-
-void CAddress::Init()
-{
-    nServices = NODE_NONE;
-    nTime = 100000000;
-}
-
 CInv::CInv()
 {
     type = 0;
diff --git a/src/protocol.h b/src/protocol.h
index 106d038b28993..78a1c96fc3861 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -389,16 +389,16 @@ static inline bool MayHaveUsefulAddressDB(ServiceFlags services) {
 /** A CService with information about it as peer */
 class CAddress : public CService
 {
-public:
-    CAddress();
-    explicit CAddress(CService ipIn, ServiceFlags nServicesIn);
-    CAddress(CService ipIn, ServiceFlags nServicesIn, uint32_t nTimeIn);
+    static constexpr uint32_t TIME_INIT{100000000};
 
-    void Init();
+public:
+    CAddress() : CService{} {};
+    explicit CAddress(CService ipIn, ServiceFlags nServicesIn) : CService{ipIn}, nServices{nServicesIn} {};
+    CAddress(CService ipIn, ServiceFlags nServicesIn, uint32_t nTimeIn) : CService{ipIn}, nTime{nTimeIn}, nServices{nServicesIn} {};
 
     SERIALIZE_METHODS(CAddress, obj)
     {
-        SER_READ(obj, obj.Init());
+        SER_READ(obj, obj.nTime = TIME_INIT);
         int nVersion = s.GetVersion();
         if (s.GetType() & SER_DISK) {
             READWRITE(nVersion);
@@ -424,12 +424,10 @@ class CAddress : public CService
         READWRITEAS(CService, obj);
     }
 
-    // TODO: make private (improves encapsulation)
-public:
-    ServiceFlags nServices;
-
     // disk and network only
-    unsigned int nTime;
+    uint32_t nTime{TIME_INIT};
+
+    ServiceFlags nServices{NODE_NONE};
 };
 
 /** getdata / inv message types.

From bda40398a59664bc20d962e7f20eb4e4c615d0cb Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sat, 2 Jan 2021 19:29:36 +0100
Subject: [PATCH 16/21] merge bitcoin#20839: Avoid extraneous copy of input
 data, using Span<>

---
 src/test/fuzz/deserialize.cpp     |  4 +---
 src/test/fuzz/fuzz.cpp            |  3 +--
 src/test/fuzz/fuzz.h              | 11 +++++++----
 src/test/fuzz/process_message.cpp |  3 +--
 4 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index fb0a9127c8c7c..ab5f2baa01762 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -29,8 +29,6 @@
 #include <stdint.h>
 #include <unistd.h>
 
-#include <vector>
-
 #include <test/fuzz/fuzz.h>
 
 void initialize_deserialize()
@@ -70,7 +68,7 @@ T Deserialize(CDataStream ds)
 }
 
 template <typename T>
-void DeserializeFromFuzzingInput(const std::vector<uint8_t>& buffer, T& obj, const std::optional<int>& protocol_version = {})
+void DeserializeFromFuzzingInput(FuzzBufferType buffer, T& obj, const std::optional<int>& protocol_version = {})
 {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     if (protocol_version) {
diff --git a/src/test/fuzz/fuzz.cpp b/src/test/fuzz/fuzz.cpp
index a0db805a25f77..9bd8cbe378813 100644
--- a/src/test/fuzz/fuzz.cpp
+++ b/src/test/fuzz/fuzz.cpp
@@ -59,8 +59,7 @@ static bool read_stdin(std::vector<uint8_t>& data)
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     static const auto& test_one_input = *Assert(g_test_one_input);
-    const std::vector<uint8_t> input(data, data + size);
-    test_one_input(input);
+    test_one_input({data, size});
     return 0;
 }
 
diff --git a/src/test/fuzz/fuzz.h b/src/test/fuzz/fuzz.h
index 73edd8220e027..90f59d15b2b49 100644
--- a/src/test/fuzz/fuzz.h
+++ b/src/test/fuzz/fuzz.h
@@ -5,12 +5,15 @@
 #ifndef BITCOIN_TEST_FUZZ_FUZZ_H
 #define BITCOIN_TEST_FUZZ_FUZZ_H
 
+#include <span.h>
+
 #include <cstdint>
 #include <functional>
 #include <string_view>
-#include <vector>
 
-using TypeTestOneInput = std::function<void(const std::vector<uint8_t>&)>;
+using FuzzBufferType = Span<const uint8_t>;
+
+using TypeTestOneInput = std::function<void(FuzzBufferType)>;
 using TypeInitialize = std::function<void()>;
 
 void FuzzFrameworkRegisterTarget(std::string_view name, TypeTestOneInput target, TypeInitialize init);
@@ -21,13 +24,13 @@ inline void FuzzFrameworkEmptyFun() {}
     FUZZ_TARGET_INIT(name, FuzzFrameworkEmptyFun)
 
 #define FUZZ_TARGET_INIT(name, init_fun)                                      \
-    void name##_fuzz_target(const std::vector<uint8_t>&);                     \
+    void name##_fuzz_target(FuzzBufferType);                                  \
     struct name##_Before_Main {                                               \
         name##_Before_Main()                                                  \
         {                                                                     \
             FuzzFrameworkRegisterTarget(#name, name##_fuzz_target, init_fun); \
         }                                                                     \
     } const static g_##name##_before_main;                                    \
-    void name##_fuzz_target(const std::vector<uint8_t>& buffer)
+    void name##_fuzz_target(FuzzBufferType buffer)
 
 #endif // BITCOIN_TEST_FUZZ_FUZZ_H
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
index 795e5b08eb0e5..94ec19bf188d3 100644
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -36,7 +36,6 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace {
 const TestingSetup* g_setup;
@@ -52,7 +51,7 @@ void initialize_process_message()
     SyncWithValidationInterfaceQueue();
 }
 
-void fuzz_target(const std::vector<uint8_t>& buffer, const std::string& LIMIT_TO_MESSAGE_TYPE)
+void fuzz_target(FuzzBufferType buffer, const std::string& LIMIT_TO_MESSAGE_TYPE)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     ConnmanTestMsg& connman = *(ConnmanTestMsg*)g_setup->m_node.connman.get();

From 3feccd7925e3f7cdddccc97cfb0a835177d367fd Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 10 Sep 2023 22:32:53 +0530
Subject: [PATCH 17/21] partial bitcoin#17428: Try to preserve outbound
 block-relay-only connections during restart

excludes:
- 0a85e5a7bc8dc6587963e2e37ac1b087a1fc97fe
---
 doc/files.md   |  1 +
 src/addrdb.cpp | 20 ++++++++++++++++++++
 src/addrdb.h   | 20 ++++++++++++++++++--
 src/net.cpp    | 51 +++++++++++++++++++++++++++++++++++++++++++-------
 src/net.h      | 11 +++++++++++
 5 files changed, 94 insertions(+), 9 deletions(-)

diff --git a/doc/files.md b/doc/files.md
index 5a517a9088df9..c34476d0ccff0 100644
--- a/doc/files.md
+++ b/doc/files.md
@@ -53,6 +53,7 @@ Subdirectory       | File(s)               | Description
 `indexes/blockfilter/basic/db/` | LevelDB database      | Blockfilter index LevelDB database for the basic filtertype; *optional*, used if `-blockfilterindex=basic`
 `indexes/blockfilter/basic/`    | `fltrNNNNN.dat`<sup>[\[2\]](#note2)</sup> | Blockfilter index filters for the basic filtertype; *optional*, used if `-blockfilterindex=basic`
 `wallets/`         |                       | [Contains wallets](#multi-wallet-environment); can be specified by `-walletdir` option; if `wallets/` subdirectory does not exist, a wallet resides in the data directory
+`./`               | `anchors.dat`         | Anchor IP address database, created on shutdown and deleted at startup. Anchors are last known outgoing block-relay-only peers that are tried to re-connect to on startup
 `evodb/`         |                       |special txes and quorums database
 `llmq/`          |                       |quorum signatures database
 `./`               | `banlist.dat`         | Stores the IPs/subnets of banned nodes
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index e7f98c9538467..4f4d11b36d9f4 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -9,6 +9,7 @@
 #include <chainparams.h>
 #include <clientversion.h>
 #include <hash.h>
+#include <logging/timer.h>
 #include <random.h>
 #include <streams.h>
 #include <tinyformat.h>
@@ -157,3 +158,22 @@ bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
     }
     return ret;
 }
+
+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);
+}
+
+std::vector<CAddress> ReadAnchors(const fs::path& anchors_db_path)
+{
+    std::vector<CAddress> anchors;
+    if (DeserializeFileDB(anchors_db_path, anchors)) {
+        LogPrintf("Loaded %i addresses from %s\n", anchors.size(), anchors_db_path.filename());
+    } else {
+        anchors.clear();
+    }
+
+    fs::remove(anchors_db_path);
+    return anchors;
+}
diff --git a/src/addrdb.h b/src/addrdb.h
index e1352645eef83..3e9605827df78 100644
--- a/src/addrdb.h
+++ b/src/addrdb.h
@@ -11,9 +11,9 @@
 #include <serialize.h>
 
 #include <string>
-#include <map>
+#include <vector>
 
-class CSubNet;
+class CAddress;
 class CAddrMan;
 class CDataStream;
 
@@ -73,4 +73,20 @@ class CBanDB
     bool Read(banmap_t& banSet);
 };
 
+/**
+ * Dump the anchor IP address database (anchors.dat)
+ *
+ * Anchors are last known outgoing block-relay-only peers that are
+ * tried to re-connect to on startup.
+ */
+void DumpAnchors(const fs::path& anchors_db_path, const std::vector<CAddress>& anchors);
+
+/**
+ * Read the anchor IP address database (anchors.dat)
+ *
+ * Deleting anchors.dat is intentional as it avoids renewed peering to anchors after
+ * an unclean shutdown and thus potential exploitation of the anchor peer policy.
+ */
+std::vector<CAddress> ReadAnchors(const fs::path& anchors_db_path);
+
 #endif // BITCOIN_ADDRDB_H
diff --git a/src/net.cpp b/src/net.cpp
index e0e231218225a..f29ea026484a8 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -64,6 +64,12 @@
 
 #include <math.h>
 
+/** Maximum number of block-relay-only anchor connections */
+static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;
+static_assert (MAX_BLOCK_RELAY_ONLY_ANCHORS <= static_cast<size_t>(MAX_BLOCK_RELAY_ONLY_CONNECTIONS), "MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed MAX_BLOCK_RELAY_ONLY_CONNECTIONS.");
+/** Anchor IP address database file name */
+const char* const ANCHORS_DATABASE_FILENAME = "anchors.dat";
+
 // How often to dump addresses to peers.dat
 static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};
 
@@ -2336,6 +2342,13 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
         int nTries = 0;
         while (!interruptNet)
         {
+            // If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
+            // stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
+            // already-connected network ranges, ...) before trying new addrman addresses.
+            nTries++;
+            if (nTries > 100)
+                break;
+
             CAddrInfo addr = addrman.SelectTriedCollision();
 
             // SelectTriedCollision returns an invalid address if it is empty.
@@ -2365,13 +2378,6 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
                 break;
             }
 
-            // If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
-            // stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
-            // already-connected network ranges, ...) before trying new addrman addresses.
-            nTries++;
-            if (nTries > 100)
-                break;
-
             if (!IsReachable(addr))
                 continue;
 
@@ -2427,6 +2433,19 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
     }
 }
 
+std::vector<CAddress> CConnman::GetCurrentBlockRelayOnlyConns() const
+{
+    std::vector<CAddress> ret;
+    LOCK(cs_vNodes);
+    for (const CNode* pnode : vNodes) {
+        if (pnode->IsBlockRelayOnly()) {
+            ret.push_back(pnode->addr);
+        }
+    }
+
+    return ret;
+}
+
 std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo()
 {
     std::vector<AddedNodeInfo> ret;
@@ -3131,6 +3150,15 @@ bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
         }
     }
 
+    if (m_use_addrman_outgoing) {
+        // Load addresses from anchors.dat
+        m_anchors = ReadAnchors(GetDataDir() / ANCHORS_DATABASE_FILENAME);
+        if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
+            m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
+        }
+        LogPrintf("%i block-relay-only anchors will be tried for connections.\n", m_anchors.size());
+    }
+
     uiInterface.InitMessage(_("Starting network threads...").translated);
 
     fAddressesInitialized = true;
@@ -3311,6 +3339,15 @@ void CConnman::StopNodes()
     if (fAddressesInitialized) {
         DumpAddresses();
         fAddressesInitialized = false;
+
+        if (m_use_addrman_outgoing) {
+            // Anchor connections are only dumped during clean shutdown.
+            std::vector<CAddress> anchors_to_dump = GetCurrentBlockRelayOnlyConns();
+            if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
+                anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
+            }
+            DumpAnchors(GetDataDir() / ANCHORS_DATABASE_FILENAME, anchors_to_dump);
+        }
     }
 
     {
diff --git a/src/net.h b/src/net.h
index ebb6a74d96329..d47236bcb26e3 100644
--- a/src/net.h
+++ b/src/net.h
@@ -572,6 +572,11 @@ friend class CNode;
     void RecordBytesRecv(uint64_t bytes);
     void RecordBytesSent(uint64_t bytes);
 
+    /**
+     * Return vector of current BLOCK_RELAY peers.
+     */
+    std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const;
+
     // Whether the node should be passed out in ForEach* callbacks
     static bool NodeFullyConnected(const CNode* pnode);
 
@@ -679,6 +684,12 @@ friend class CNode;
     NetEventsInterface* m_msgproc;
     BanMan* m_banman;
 
+    /**
+     * Addresses that were saved during the previous clean shutdown. We'll
+     * attempt to make block-relay-only connections to them.
+     */
+    std::vector<CAddress> m_anchors;
+
     /** SipHasher seeds for deterministic randomness */
     const uint64_t nSeed0, nSeed1;
 

From 0e2ca7d3a575c07af23123e19adf6ba7ea6072a8 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 10 Sep 2023 18:53:03 +0530
Subject: [PATCH 18/21] merge bitcoin#20516: Well-defined CAddress disk
 serialization, and addrv2 anchors.dat

---
 src/addrdb.cpp                | 22 +++++-----
 src/protocol.h                | 83 ++++++++++++++++++++++++++++++-----
 src/test/fuzz/deserialize.cpp | 44 +++++++++++++++----
 3 files changed, 119 insertions(+), 30 deletions(-)

diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index 4f4d11b36d9f4..a2155e662c3b9 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -24,7 +24,7 @@ bool SerializeDB(Stream& stream, const Data& data)
 {
     // Write and commit header, data
     try {
-        CHashWriter hasher(SER_DISK, CLIENT_VERSION);
+        CHashWriter hasher(stream.GetType(), stream.GetVersion());
         stream << Params().MessageStart() << data;
         hasher << Params().MessageStart() << data;
         stream << hasher.GetHash();
@@ -36,7 +36,7 @@ bool SerializeDB(Stream& stream, const Data& data)
 }
 
 template <typename Data>
-bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data& data)
+bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data& data, int version)
 {
     // Generate random temporary filename
     uint16_t randv = 0;
@@ -46,7 +46,7 @@ bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data
     // open temp output file, and associate with CAutoFile
     fs::path pathTmp = GetDataDir() / tmpfn;
     FILE *file = fsbridge::fopen(pathTmp, "wb");
-    CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
+    CAutoFile fileout(file, SER_DISK, version);
     if (fileout.IsNull()) {
         fileout.fclose();
         remove(pathTmp);
@@ -107,11 +107,11 @@ bool DeserializeDB(Stream& stream, Data& data, bool fCheckSum = true)
 }
 
 template <typename Data>
-bool DeserializeFileDB(const fs::path& path, Data& data)
+bool DeserializeFileDB(const fs::path& path, Data& data, int version)
 {
     // open input file, and associate with CAutoFile
     FILE* file = fsbridge::fopen(path, "rb");
-    CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
+    CAutoFile filein(file, SER_DISK, version);
     if (filein.IsNull()) {
         LogPrintf("Missing or invalid file %s\n", path.string());
         return false;
@@ -126,12 +126,12 @@ CBanDB::CBanDB(fs::path ban_list_path) : m_ban_list_path(std::move(ban_list_path
 
 bool CBanDB::Write(const banmap_t& banSet)
 {
-    return SerializeFileDB("banlist", m_ban_list_path, banSet);
+    return SerializeFileDB("banlist", m_ban_list_path, banSet, CLIENT_VERSION);
 }
 
 bool CBanDB::Read(banmap_t& banSet)
 {
-    return DeserializeFileDB(m_ban_list_path, banSet);
+    return DeserializeFileDB(m_ban_list_path, banSet, CLIENT_VERSION);
 }
 
 CAddrDB::CAddrDB()
@@ -141,12 +141,12 @@ CAddrDB::CAddrDB()
 
 bool CAddrDB::Write(const CAddrMan& addr)
 {
-    return SerializeFileDB("peers", pathAddr, addr);
+    return SerializeFileDB("peers", pathAddr, addr, CLIENT_VERSION);
 }
 
 bool CAddrDB::Read(CAddrMan& addr)
 {
-    return DeserializeFileDB(pathAddr, addr);
+    return DeserializeFileDB(pathAddr, addr, CLIENT_VERSION);
 }
 
 bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
@@ -162,13 +162,13 @@ bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
 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);
+    SerializeFileDB("anchors", anchors_db_path, anchors, CLIENT_VERSION | ADDRV2_FORMAT);
 }
 
 std::vector<CAddress> ReadAnchors(const fs::path& anchors_db_path)
 {
     std::vector<CAddress> anchors;
-    if (DeserializeFileDB(anchors_db_path, anchors)) {
+    if (DeserializeFileDB(anchors_db_path, anchors, CLIENT_VERSION | ADDRV2_FORMAT)) {
         LogPrintf("Loaded %i addresses from %s\n", anchors.size(), anchors_db_path.filename());
     } else {
         anchors.clear();
diff --git a/src/protocol.h b/src/protocol.h
index 78a1c96fc3861..ebabae1be080d 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -12,6 +12,7 @@
 
 #include <netaddress.h>
 #include <serialize.h>
+#include <streams.h>
 #include <uint256.h>
 #include <version.h>
 
@@ -391,6 +392,31 @@ class CAddress : public CService
 {
     static constexpr uint32_t TIME_INIT{100000000};
 
+    /** Historically, CAddress disk serialization stored the CLIENT_VERSION, optionally OR'ed with
+     *  the ADDRV2_FORMAT flag to indicate V2 serialization. The first field has since been
+     *  disentangled from client versioning, and now instead:
+     *  - The low bits (masked by DISK_VERSION_IGNORE_MASK) store the fixed value DISK_VERSION_INIT,
+     *    (in case any code exists that treats it as a client version) but are ignored on
+     *    deserialization.
+     *  - The high bits (masked by ~DISK_VERSION_IGNORE_MASK) store actual serialization information.
+     *    Only 0 or DISK_VERSION_ADDRV2 (equal to the historical ADDRV2_FORMAT) are valid now, and
+     *    any other value triggers a deserialization failure. Other values can be added later if
+     *    needed.
+     *
+     *  For disk deserialization, ADDRV2_FORMAT in the stream version signals that ADDRV2
+     *  deserialization is permitted, but the actual format is determined by the high bits in the
+     *  stored version field. For network serialization, the stream version having ADDRV2_FORMAT or
+     *  not determines the actual format used (as it has no embedded version number).
+     */
+    static constexpr uint32_t DISK_VERSION_INIT{220000};
+    static constexpr uint32_t DISK_VERSION_IGNORE_MASK{0b00000000'00000111'11111111'11111111};
+    /** The version number written in disk serialized addresses to indicate V2 serializations.
+     * It must be exactly 1<<29, as that is the value that historical versions used for this
+     * (they used their internal ADDRV2_FORMAT flag here). */
+    static constexpr uint32_t DISK_VERSION_ADDRV2{1 << 29};
+    static_assert((DISK_VERSION_INIT & ~DISK_VERSION_IGNORE_MASK) == 0, "DISK_VERSION_INIT must be covered by DISK_VERSION_IGNORE_MASK");
+    static_assert((DISK_VERSION_ADDRV2 & DISK_VERSION_IGNORE_MASK) == 0, "DISK_VERSION_ADDRV2 must not be covered by DISK_VERSION_IGNORE_MASK");
+
 public:
     CAddress() : CService{} {};
     explicit CAddress(CService ipIn, ServiceFlags nServicesIn) : CService{ipIn}, nServices{nServicesIn} {};
@@ -398,22 +424,48 @@ class CAddress : public CService
 
     SERIALIZE_METHODS(CAddress, obj)
     {
-        SER_READ(obj, obj.nTime = TIME_INIT);
-        int nVersion = s.GetVersion();
+        // CAddress has a distinct network serialization and a disk serialization, but it should never
+        // be hashed (except through CHashWriter in addrdb.cpp, which sets SER_DISK), and it's
+        // ambiguous what that would mean. Make sure no code relying on that is introduced:
+        assert(!(s.GetType() & SER_GETHASH));
+        bool use_v2;
+        bool store_time;
         if (s.GetType() & SER_DISK) {
-            READWRITE(nVersion);
-        }
-        if ((s.GetType() & SER_DISK) ||
-            (nVersion != INIT_PROTO_VERSION && !(s.GetType() & SER_GETHASH))) {
+            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
+            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
+            // whether V2 is chosen/permitted at all.
+            uint32_t stored_format_version = DISK_VERSION_INIT;
+            if (s.GetVersion() & ADDRV2_FORMAT) stored_format_version |= DISK_VERSION_ADDRV2;
+            READWRITE(stored_format_version);
+            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
+            if (stored_format_version == 0) {
+                use_v2 = false;
+            } else if (stored_format_version == DISK_VERSION_ADDRV2 && (s.GetVersion() & ADDRV2_FORMAT)) {
+                // Only support v2 deserialization if ADDRV2_FORMAT is set.
+                use_v2 = true;
+            } else {
+                throw std::ios_base::failure("Unsupported CAddress disk format version");
+            }
+            store_time = true;
+        } else {
+            // In the network serialization format, the encoding (v1 or v2) is determined directly by
+            // the value of ADDRV2_FORMAT in the stream version, as no explicitly encoded version
+            // exists in the stream.
+            assert(s.GetType() & SER_NETWORK);
+            use_v2 = s.GetVersion() & ADDRV2_FORMAT;
             // The only time we serialize a CAddress object without nTime is in
             // the initial VERSION messages which contain two CAddress records.
             // At that point, the serialization version is INIT_PROTO_VERSION.
             // After the version handshake, serialization version is >=
             // MIN_PEER_PROTO_VERSION and all ADDR messages are serialized with
             // nTime.
-            READWRITE(obj.nTime);
+            store_time = s.GetVersion() != INIT_PROTO_VERSION;
         }
-        if (nVersion & ADDRV2_FORMAT) {
+
+        SER_READ(obj, obj.nTime = TIME_INIT);
+        if (store_time) READWRITE(obj.nTime);
+        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
+        if (use_v2) {
             uint64_t services_tmp;
             SER_WRITE(obj, services_tmp = obj.nServices);
             READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
@@ -421,13 +473,22 @@ class CAddress : public CService
         } else {
             READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
         }
-        READWRITEAS(CService, obj);
+        // Invoke V1/V2 serializer for CService parent object.
+        OverrideStream<Stream> os(&s, s.GetType(), use_v2 ? ADDRV2_FORMAT : 0);
+        SerReadWriteMany(os, ser_action, ReadWriteAsHelper<CService>(obj));
     }
 
-    // disk and network only
+    //! Always included in serialization, except in the network format on INIT_PROTO_VERSION.
     uint32_t nTime{TIME_INIT};
-
+    //! Serialized as uint64_t in V1, and as CompactSize in V2.
     ServiceFlags nServices{NODE_NONE};
+
+    friend bool operator==(const CAddress& a, const CAddress& b)
+    {
+        return a.nTime == b.nTime &&
+               a.nServices == b.nServices &&
+               static_cast<const CService&>(a) == static_cast<const CService&>(b);
+    }
 };
 
 /** getdata / inv message types.
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index ab5f2baa01762..39ed4d464afd6 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -52,9 +52,9 @@ struct invalid_fuzzing_input_exception : public std::exception {
 };
 
 template <typename T>
-CDataStream Serialize(const T& obj, const int version = INIT_PROTO_VERSION)
+CDataStream Serialize(const T& obj, const int version = INIT_PROTO_VERSION, const int ser_type = SER_NETWORK)
 {
-    CDataStream ds(SER_NETWORK, version);
+    CDataStream ds(ser_type, version);
     ds << obj;
     return ds;
 }
@@ -68,9 +68,9 @@ T Deserialize(CDataStream ds)
 }
 
 template <typename T>
-void DeserializeFromFuzzingInput(FuzzBufferType buffer, T& obj, const std::optional<int>& protocol_version = {})
+void DeserializeFromFuzzingInput(FuzzBufferType buffer, T& obj, const std::optional<int> protocol_version = std::nullopt, const int ser_type = SER_NETWORK)
 {
-    CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
+    CDataStream ds(buffer, ser_type, INIT_PROTO_VERSION);
     if (protocol_version) {
         ds.SetVersion(*protocol_version);
     } else {
@@ -91,9 +91,9 @@ void DeserializeFromFuzzingInput(FuzzBufferType buffer, T& obj, const std::optio
 }
 
 template <typename T>
-void AssertEqualAfterSerializeDeserialize(const T& obj, const int version = INIT_PROTO_VERSION)
+void AssertEqualAfterSerializeDeserialize(const T& obj, const int version = INIT_PROTO_VERSION, const int ser_type = SER_NETWORK)
 {
-    assert(Deserialize<T>(Serialize(obj, version)) == obj);
+    assert(Deserialize<T>(Serialize(obj, version, ser_type)) == obj);
 }
 
 } // namespace
@@ -253,9 +253,37 @@ FUZZ_TARGET_DESERIALIZE(messageheader_deserialize, {
         DeserializeFromFuzzingInput(buffer, mh);
         (void)mh.IsCommandValid();
 })
-FUZZ_TARGET_DESERIALIZE(address_deserialize, {
+FUZZ_TARGET_DESERIALIZE(address_deserialize_v1_notime, {
         CAddress a;
-        DeserializeFromFuzzingInput(buffer, a);
+        DeserializeFromFuzzingInput(buffer, a, INIT_PROTO_VERSION);
+        // A CAddress without nTime (as is expected under INIT_PROTO_VERSION) will roundtrip
+        // in all 5 formats (with/without nTime, v1/v2, network/disk)
+        AssertEqualAfterSerializeDeserialize(a, INIT_PROTO_VERSION);
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+})
+FUZZ_TARGET_DESERIALIZE(address_deserialize_v1_withtime, {
+        CAddress a;
+        DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION);
+        // A CAddress in V1 mode will roundtrip in all 4 formats that have nTime.
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+})
+FUZZ_TARGET_DESERIALIZE(address_deserialize_v2, {
+        CAddress a;
+        DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+        // A CAddress in V2 mode will roundtrip in both V2 formats, and also in the V1 formats
+        // with time if it's V1 compatible.
+        if (a.IsAddrV1Compatible()) {
+            AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+            AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+        }
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(inv_deserialize, {
         CInv i;

From c3b4b6746a1f16e3c94f42daf0cca24c7c1a64b6 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 10 Sep 2023 19:19:43 +0530
Subject: [PATCH 19/21] merge bitcoin#20966: save the banlist in a JSON format
 on disk

---
 doc/files.md                       |   5 +-
 src/addrdb.cpp                     | 103 +++++++++++++++++++++++++++--
 src/addrdb.h                       |  35 +++++++++-
 src/banman.cpp                     |  33 ++++-----
 src/banman.h                       |   6 +-
 src/init.cpp                       |   2 +-
 src/test/denialofservice_tests.cpp |   6 +-
 src/test/fuzz/banman.cpp           |  21 +++++-
 src/test/util/setup_common.cpp     |   2 +-
 test/functional/rpc_setban.py      |  31 ++++++---
 10 files changed, 194 insertions(+), 50 deletions(-)

diff --git a/doc/files.md b/doc/files.md
index c34476d0ccff0..58cd234390c67 100644
--- a/doc/files.md
+++ b/doc/files.md
@@ -56,7 +56,8 @@ Subdirectory       | File(s)               | Description
 `./`               | `anchors.dat`         | Anchor IP address database, created on shutdown and deleted at startup. Anchors are last known outgoing block-relay-only peers that are tried to re-connect to on startup
 `evodb/`         |                       |special txes and quorums database
 `llmq/`          |                       |quorum signatures database
-`./`               | `banlist.dat`         | Stores the IPs/subnets of banned nodes
+`./`               | `banlist.dat`         | Stores the addresses/subnets of banned nodes (deprecated). `dashd` or `dash-qt` no longer save the banlist to this file, but read it on startup if `banlist.json` is not present.
+`./`               | `banlist.json`        | Stores the addresses/subnets of banned nodes.
 `./`               | `dash.conf`        | User-defined [configuration settings](dash-conf.md) for `dashd` or `dash-qt`. File is not written to by the software and must be created manually. Path can be specified by `-conf` option
 `./`               | `dashd.pid`        | Stores the process ID (PID) of `dashd` or `dash-qt` while running; created at start and deleted on shutdown; can be specified by `-pid` option
 `./`               | `debug.log`           | Contains debug information and general logging generated by `dashd` or `dash-qt`; can be specified by `-debuglogfile` option
@@ -111,7 +112,7 @@ Subdirectory | File                 | Description
 
 ## Legacy subdirectories and files
 
-These subdirectories and files are no longer used by the Dash Core:
+These subdirectories and files are no longer used by Dash Core:
 
 Path           | Description | Repository notes
 ---------------|-------------|-----------------
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index a2155e662c3b9..12e1ee4bacba8 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -10,15 +10,74 @@
 #include <clientversion.h>
 #include <hash.h>
 #include <logging/timer.h>
+#include <netbase.h>
 #include <random.h>
 #include <streams.h>
 #include <tinyformat.h>
+#include <univalue.h>
+#include <util/settings.h>
 #include <util/system.h>
 
 #include <cstdint>
 
+CBanEntry::CBanEntry(const UniValue& json)
+    : nVersion(json["version"].get_int()), nCreateTime(json["ban_created"].get_int64()),
+      nBanUntil(json["banned_until"].get_int64())
+{
+}
+
+UniValue CBanEntry::ToJson() const
+{
+    UniValue json(UniValue::VOBJ);
+    json.pushKV("version", nVersion);
+    json.pushKV("ban_created", nCreateTime);
+    json.pushKV("banned_until", nBanUntil);
+    return json;
+}
+
 namespace {
 
+static const char* BANMAN_JSON_ADDR_KEY = "address";
+
+/**
+ * Convert a `banmap_t` object to a JSON array.
+ * @param[in] bans Bans list to convert.
+ * @return a JSON array, similar to the one returned by the `listbanned` RPC. Suitable for
+ * passing to `BanMapFromJson()`.
+ */
+UniValue BanMapToJson(const banmap_t& bans)
+{
+    UniValue bans_json(UniValue::VARR);
+    for (const auto& it : bans) {
+        const auto& address = it.first;
+        const auto& ban_entry = it.second;
+        UniValue j = ban_entry.ToJson();
+        j.pushKV(BANMAN_JSON_ADDR_KEY, address.ToString());
+        bans_json.push_back(j);
+    }
+    return bans_json;
+}
+
+/**
+ * Convert a JSON array to a `banmap_t` object.
+ * @param[in] bans_json JSON to convert, must be as returned by `BanMapToJson()`.
+ * @param[out] bans Bans list to create from the JSON.
+ * @throws std::runtime_error if the JSON does not have the expected fields or they contain
+ * unparsable values.
+ */
+void BanMapFromJson(const UniValue& bans_json, banmap_t& bans)
+{
+    for (const auto& ban_entry_json : bans_json.getValues()) {
+        CSubNet subnet;
+        const auto& subnet_str = ban_entry_json[BANMAN_JSON_ADDR_KEY].get_str();
+        if (!LookupSubNet(subnet_str, subnet)) {
+            throw std::runtime_error(
+                strprintf("Cannot parse banned address or subnet: %s", subnet_str));
+        }
+        bans.insert_or_assign(subnet, CBanEntry{ban_entry_json});
+    }
+}
+
 template <typename Stream, typename Data>
 bool SerializeDB(Stream& stream, const Data& data)
 {
@@ -120,18 +179,54 @@ bool DeserializeFileDB(const fs::path& path, Data& data, int version)
 }
 } // namespace
 
-CBanDB::CBanDB(fs::path ban_list_path) : m_ban_list_path(std::move(ban_list_path))
+CBanDB::CBanDB(fs::path ban_list_path)
+    : m_banlist_dat(ban_list_path.string() + ".dat"),
+      m_banlist_json(ban_list_path.string() + ".json")
 {
 }
 
 bool CBanDB::Write(const banmap_t& banSet)
 {
-    return SerializeFileDB("banlist", m_ban_list_path, banSet, CLIENT_VERSION);
+    std::vector<std::string> errors;
+    if (util::WriteSettings(m_banlist_json, {{JSON_KEY, BanMapToJson(banSet)}}, errors)) {
+        return true;
+    }
+
+    for (const auto& err : errors) {
+        error("%s", err);
+    }
+    return false;
 }
 
-bool CBanDB::Read(banmap_t& banSet)
+bool CBanDB::Read(banmap_t& banSet, bool& dirty)
 {
-    return DeserializeFileDB(m_ban_list_path, banSet, CLIENT_VERSION);
+    // If the JSON banlist does not exist, then try to read the non-upgraded banlist.dat.
+    if (!fs::exists(m_banlist_json)) {
+        // If this succeeds then we need to flush to disk in order to create the JSON banlist.
+        dirty = true;
+        return DeserializeFileDB(m_banlist_dat, banSet, CLIENT_VERSION);
+    }
+
+    dirty = false;
+
+    std::map<std::string, util::SettingsValue> settings;
+    std::vector<std::string> errors;
+
+    if (!util::ReadSettings(m_banlist_json, settings, errors)) {
+        for (const auto& err : errors) {
+            LogPrintf("Cannot load banlist %s: %s\n", m_banlist_json.string(), err);
+        }
+        return false;
+    }
+
+    try {
+        BanMapFromJson(settings[JSON_KEY], banSet);
+    } catch (const std::runtime_error& e) {
+        LogPrintf("Cannot parse banlist %s: %s\n", m_banlist_json.string(), e.what());
+        return false;
+    }
+
+    return true;
 }
 
 CAddrDB::CAddrDB()
diff --git a/src/addrdb.h b/src/addrdb.h
index 3e9605827df78..88dec7db51f89 100644
--- a/src/addrdb.h
+++ b/src/addrdb.h
@@ -9,6 +9,7 @@
 #include <fs.h>
 #include <net_types.h> // For banmap_t
 #include <serialize.h>
+#include <univalue.h>
 
 #include <string>
 #include <vector>
@@ -36,6 +37,13 @@ class CBanEntry
         nCreateTime = nCreateTimeIn;
     }
 
+    /**
+     * Create a ban entry from JSON.
+     * @param[in] json A JSON representation of a ban entry, as created by `ToJson()`.
+     * @throw std::runtime_error if the JSON does not have the expected fields.
+     */
+    explicit CBanEntry(const UniValue& json);
+
     SERIALIZE_METHODS(CBanEntry, obj)
     {
         uint8_t ban_reason = 2; //! For backward compatibility
@@ -48,6 +56,12 @@ class CBanEntry
         nCreateTime = 0;
         nBanUntil = 0;
     }
+
+    /**
+     * Generate a JSON representation of this ban entry.
+     * @return JSON suitable for passing to the `CBanEntry(const UniValue&)` constructor.
+     */
+    UniValue ToJson() const;
 };
 
 /** Access to the (IP) address database (peers.dat) */
@@ -62,15 +76,30 @@ class CAddrDB
     static bool Read(CAddrMan& addr, CDataStream& ssPeers);
 };
 
-/** Access to the banlist database (banlist.dat) */
+/** Access to the banlist databases (banlist.json and banlist.dat) */
 class CBanDB
 {
 private:
-    const fs::path m_ban_list_path;
+    /**
+     * JSON key under which the data is stored in the json database.
+     */
+    static constexpr const char* JSON_KEY = "banned_nets";
+
+    const fs::path m_banlist_dat;
+    const fs::path m_banlist_json;
 public:
     explicit CBanDB(fs::path ban_list_path);
     bool Write(const banmap_t& banSet);
-    bool Read(banmap_t& banSet);
+
+    /**
+     * Read the banlist from disk.
+     * @param[out] banSet The loaded list. Set if `true` is returned, otherwise it is left
+     * in an undefined state.
+     * @param[out] dirty Indicates whether the loaded list needs flushing to disk. Set if
+     * `true` is returned, otherwise it is left in an undefined state.
+     * @return true on success
+     */
+    bool Read(banmap_t& banSet, bool& dirty);
 };
 
 /**
diff --git a/src/banman.cpp b/src/banman.cpp
index 807ad19faa0ac..ba1db1157791a 100644
--- a/src/banman.cpp
+++ b/src/banman.cpp
@@ -18,20 +18,18 @@ BanMan::BanMan(fs::path ban_file, CClientUIInterface* client_interface, int64_t
     if (m_client_interface) m_client_interface->InitMessage(_("Loading banlist...").translated);
 
     int64_t n_start = GetTimeMillis();
-    m_is_dirty = false;
-    banmap_t banmap;
-    if (m_ban_db.Read(banmap)) {
-        SetBanned(banmap);        // thread save setter
-        SetBannedSetDirty(false); // no need to write down, just read data
-        SweepBanned();            // sweep out unused entries
+    if (m_ban_db.Read(m_banned, m_is_dirty)) {
+        SweepBanned(); // sweep out unused entries
 
-        LogPrint(BCLog::NET, "Loaded %d banned node ips/subnets from banlist.dat  %dms\n",
-            m_banned.size(), GetTimeMillis() - n_start);
+        LogPrint(BCLog::NET, "Loaded %d banned node addresses/subnets  %dms\n", m_banned.size(),
+                 GetTimeMillis() - n_start);
     } else {
-        LogPrintf("Recreating banlist.dat\n");
-        SetBannedSetDirty(true); // force write
-        DumpBanlist();
+        LogPrintf("Recreating the banlist database\n");
+        m_banned = {};
+        m_is_dirty = true;
     }
+
+    DumpBanlist();
 }
 
 BanMan::~BanMan()
@@ -53,8 +51,8 @@ void BanMan::DumpBanlist()
         SetBannedSetDirty(false);
     }
 
-    LogPrint(BCLog::NET, "Flushed %d banned node ips/subnets to banlist.dat  %dms\n",
-        banmap.size(), GetTimeMillis() - n_start);
+    LogPrint(BCLog::NET, "Flushed %d banned node addresses/subnets to disk  %dms\n", banmap.size(),
+             GetTimeMillis() - n_start);
 }
 
 void BanMan::ClearBanned()
@@ -177,13 +175,6 @@ void BanMan::GetBanned(banmap_t& banmap)
     banmap = m_banned; //create a thread safe copy
 }
 
-void BanMan::SetBanned(const banmap_t& banmap)
-{
-    LOCK(m_cs_banned);
-    m_banned = banmap;
-    m_is_dirty = true;
-}
-
 void BanMan::SweepBanned()
 {
     int64_t now = GetTime();
@@ -198,7 +189,7 @@ void BanMan::SweepBanned()
                 m_banned.erase(it++);
                 m_is_dirty = true;
                 notify_ui = true;
-                LogPrint(BCLog::NET, "%s: Removed banned node ip/subnet from banlist.dat: %s\n", __func__, sub_net.ToString());
+                LogPrint(BCLog::NET, "Removed banned node address/subnet: %s\n", sub_net.ToString());
             } else
                 ++it;
         }
diff --git a/src/banman.h b/src/banman.h
index e11d4e0c8218a..06f18ea826c0d 100644
--- a/src/banman.h
+++ b/src/banman.h
@@ -17,7 +17,8 @@
 
 // NOTE: When adjusting this, update rpcnet:setban's help ("24h")
 static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME = 60 * 60 * 24; // Default 24-hour ban
-// How often to dump addresses to banlist.dat
+
+/// How often to dump banned addresses/subnets to disk.
 static constexpr std::chrono::minutes DUMP_BANS_INTERVAL{15};
 
 class CClientUIInterface;
@@ -30,7 +31,7 @@ class CSubNet;
 // If an address or subnet is banned, we never accept incoming connections from
 // it and never create outgoing connections to it. We won't gossip its address
 // to other peers in addr messages. Banned addresses and subnets are stored to
-// banlist.dat on shutdown and reloaded on startup. Banning can be used to
+// disk on shutdown and reloaded on startup. Banning can be used to
 // prevent connections with spy nodes or other griefers.
 //
 // 2. Discouragement. If a peer misbehaves enough (see Misbehaving() in
@@ -80,7 +81,6 @@ class BanMan
     void DumpBanlist();
 
 private:
-    void SetBanned(const banmap_t& banmap);
     bool BannedSetIsDirty();
     //!set the "dirty" flag for the banlist
     void SetBannedSetDirty(bool dirty = true);
diff --git a/src/init.cpp b/src/init.cpp
index 9d206ab8796e6..962681200ee15 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1662,7 +1662,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     assert(!node.addrman);
     node.addrman = std::make_unique<CAddrMan>();
     assert(!node.banman);
-    node.banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", &uiInterface, args.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
+    node.banman = std::make_unique<BanMan>(GetDataDir() / "banlist", &uiInterface, args.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
     assert(!node.connman);
     node.connman = std::make_unique<CConnman>(GetRand(std::numeric_limits<uint64_t>::max()), GetRand(std::numeric_limits<uint64_t>::max()), *node.addrman);
 
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index 0e3e619d2bcca..f737f5ecc48ca 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -226,7 +226,7 @@ BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
 BOOST_AUTO_TEST_CASE(DoS_banning)
 {
     const CChainParams& chainparams = Params();
-    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(0x1337, 0x1337, *m_node.addrman);
     auto peerLogic = PeerManager::make(chainparams, *connman, *m_node.addrman, banman.get(), *m_node.scheduler,
                                        *m_node.chainman, *m_node.mempool, *governance, m_node.cj_ctx,
@@ -274,7 +274,7 @@ BOOST_AUTO_TEST_CASE(DoS_banning)
 BOOST_AUTO_TEST_CASE(DoS_banscore)
 {
     const CChainParams& chainparams = Params();
-    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(0x1337, 0x1337, *m_node.addrman);
     auto peerLogic = PeerManager::make(chainparams, *connman, *m_node.addrman, banman.get(), *m_node.scheduler,
                                        *m_node.chainman, *m_node.mempool, *governance, m_node.cj_ctx,
@@ -320,7 +320,7 @@ BOOST_AUTO_TEST_CASE(DoS_banscore)
 BOOST_AUTO_TEST_CASE(DoS_bantime)
 {
     const CChainParams& chainparams = Params();
-    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(0x1337, 0x1337, *m_node.addrman);
     auto peerLogic = PeerManager::make(chainparams, *connman, *m_node.addrman, banman.get(), *m_node.scheduler,
                                        *m_node.chainman, *m_node.mempool, *governance, m_node.cj_ctx,
diff --git a/src/test/fuzz/banman.cpp b/src/test/fuzz/banman.cpp
index bd2dce6a40be5..5fd53b2d58c65 100644
--- a/src/test/fuzz/banman.cpp
+++ b/src/test/fuzz/banman.cpp
@@ -8,8 +8,10 @@
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
+#include <util/readwritefile.h>
 #include <util/system.h>
 
+#include <cassert>
 #include <cstdint>
 #include <limits>
 #include <string>
@@ -37,8 +39,20 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
     int limit_max_ops{300};
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     SetMockTime(ConsumeTime(fuzzed_data_provider));
-    const fs::path banlist_file = GetDataDir() / "fuzzed_banlist.dat";
-    fs::remove(banlist_file);
+    fs::path banlist_file = GetDataDir() / "fuzzed_banlist";
+
+    const bool start_with_corrupted_banlist{fuzzed_data_provider.ConsumeBool()};
+    if (start_with_corrupted_banlist) {
+        const std::string sfx{fuzzed_data_provider.ConsumeBool() ? ".dat" : ".json"};
+        assert(WriteBinaryFile(banlist_file.string() + sfx,
+                               fuzzed_data_provider.ConsumeRandomLengthString()));
+    } else {
+        const bool force_read_and_write_to_err{fuzzed_data_provider.ConsumeBool()};
+        if (force_read_and_write_to_err) {
+            banlist_file = fs::path{"path"} / "to" / "inaccessible" / "fuzzed_banlist";
+        }
+    }
+
     {
         BanMan ban_man{banlist_file, nullptr, ConsumeBanTimeOffset(fuzzed_data_provider)};
         while (--limit_max_ops >= 0 && fuzzed_data_provider.ConsumeBool()) {
@@ -79,5 +93,6 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
                 });
         }
     }
-    fs::remove(banlist_file);
+    fs::remove(banlist_file.string() + ".dat");
+    fs::remove(banlist_file.string() + ".json");
 }
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index c393f1d8dec27..7a66cf10b151a 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -261,7 +261,7 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
         throw std::runtime_error("LoadGenesisBlock failed.");
     }
 
-    m_node.banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    m_node.banman = std::make_unique<BanMan>(GetDataDir() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     m_node.peerman = PeerManager::make(chainparams, *m_node.connman, *m_node.addrman, m_node.banman.get(),
                                        *m_node.scheduler, *m_node.chainman, *m_node.mempool, *governance,
                                        m_node.cj_ctx, m_node.llmq_ctx, false);
diff --git a/test/functional/rpc_setban.py b/test/functional/rpc_setban.py
index a185b353b3e1c..16e47223790b1 100755
--- a/test/functional/rpc_setban.py
+++ b/test/functional/rpc_setban.py
@@ -22,7 +22,7 @@ def run_test(self):
         # Node 0 connects to Node 1, check that the noban permission is not granted
         self.connect_nodes(0, 1)
         peerinfo = self.nodes[1].getpeerinfo()[0]
-        assert not 'noban' in peerinfo['permissions']
+        assert not "noban" in peerinfo["permissions"]
 
         # Node 0 get banned by Node 1
         self.nodes[1].setban("127.0.0.1", "add")
@@ -36,27 +36,40 @@ def run_test(self):
         self.restart_node(1, ['-whitelist=127.0.0.1'])
         self.connect_nodes(0, 1)
         peerinfo = self.nodes[1].getpeerinfo()[0]
-        assert 'noban' in peerinfo['permissions']
+        assert "noban" in peerinfo["permissions"]
 
         # If we remove the ban, Node 0 should be able to reconnect even without noban permission
         self.nodes[1].setban("127.0.0.1", "remove")
         self.restart_node(1, [])
         self.connect_nodes(0, 1)
         peerinfo = self.nodes[1].getpeerinfo()[0]
-        assert not 'noban' in peerinfo['permissions']
+        assert not "noban" in peerinfo["permissions"]
 
         self.log.info("Test that a non-IP address can be banned/unbanned")
         node = self.nodes[1]
         tor_addr = "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"
         ip_addr = "1.2.3.4"
-        assert(not self.is_banned(node, tor_addr))
-        assert(not self.is_banned(node, ip_addr))
+        assert not self.is_banned(node, tor_addr)
+        assert not self.is_banned(node, ip_addr)
+
         node.setban(tor_addr, "add")
-        assert(self.is_banned(node, tor_addr))
-        assert(not self.is_banned(node, ip_addr))
+        assert self.is_banned(node, tor_addr)
+        assert not self.is_banned(node, ip_addr)
+
+        self.log.info("Test the ban list is preserved through restart")
+
+        self.restart_node(1)
+        assert self.is_banned(node, tor_addr)
+        assert not self.is_banned(node, ip_addr)
+
         node.setban(tor_addr, "remove")
-        assert(not self.is_banned(self.nodes[1], tor_addr))
-        assert(not self.is_banned(node, ip_addr))
+        assert not self.is_banned(self.nodes[1], tor_addr)
+        assert not self.is_banned(node, ip_addr)
+
+        self.restart_node(1)
+        assert not self.is_banned(node, tor_addr)
+        assert not self.is_banned(node, ip_addr)
+
 
 if __name__ == '__main__':
     SetBanTests().main()

From b89963abf22891cfff0d3f16c752a284aa2669bc Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 20 Sep 2023 16:35:01 +0530
Subject: [PATCH 20/21] merge bitcoin#22570: Ignore banlist.dat

---
 doc/files.md                  |   2 +-
 src/addrdb.cpp                |  13 +-
 src/addrdb.h                  |   6 +-
 src/banman.cpp                |   2 +-
 src/banman.h                  |   2 +-
 src/netaddress.h              | 840 +++++++++++++++++-----------------
 src/test/fuzz/banman.cpp      |   4 +-
 src/test/fuzz/deserialize.cpp | 275 ++++++-----
 8 files changed, 554 insertions(+), 590 deletions(-)

diff --git a/doc/files.md b/doc/files.md
index 58cd234390c67..a6dea3137a425 100644
--- a/doc/files.md
+++ b/doc/files.md
@@ -56,7 +56,6 @@ Subdirectory       | File(s)               | Description
 `./`               | `anchors.dat`         | Anchor IP address database, created on shutdown and deleted at startup. Anchors are last known outgoing block-relay-only peers that are tried to re-connect to on startup
 `evodb/`         |                       |special txes and quorums database
 `llmq/`          |                       |quorum signatures database
-`./`               | `banlist.dat`         | Stores the addresses/subnets of banned nodes (deprecated). `dashd` or `dash-qt` no longer save the banlist to this file, but read it on startup if `banlist.json` is not present.
 `./`               | `banlist.json`        | Stores the addresses/subnets of banned nodes.
 `./`               | `dash.conf`        | User-defined [configuration settings](dash-conf.md) for `dashd` or `dash-qt`. File is not written to by the software and must be created manually. Path can be specified by `-conf` option
 `./`               | `dashd.pid`        | Stores the process ID (PID) of `dashd` or `dash-qt` while running; created at start and deleted on shutdown; can be specified by `-pid` option
@@ -116,6 +115,7 @@ These subdirectories and files are no longer used by Dash Core:
 
 Path           | Description | Repository notes
 ---------------|-------------|-----------------
+`banlist.dat`  | Stores the addresses/subnets of banned nodes; completely ignored and superseded by `banlist.json` in 20.0 | [PR #5574](https://github.com/dashpay/dash/pull/5574)
 `blktree/`     | Blockchain index; replaced by `blocks/index/` in [0.8.0](https://github.com/dash/dash/blob/master/doc/release-notes/release-notes-0.8.0.md#improvements) | [PR #2231](https://github.com/dash/dash/pull/2231), [`8fdc94cc`](https://github.com/dash/dash/commit/8fdc94cc8f0341e96b1edb3a5b56811c0b20bd15)
 `coins/`       | Unspent transaction output database; replaced by `chainstate/` in 0.8.0 | [PR #2231](https://github.com/dash/dash/pull/2231), [`8fdc94cc`](https://github.com/dash/dash/commit/8fdc94cc8f0341e96b1edb3a5b56811c0b20bd15)
 `blkindex.dat` | Blockchain index BDB database; replaced by {`chainstate/`, `blocks/index/`, `blocks/revNNNNN.dat`<sup>[\[2\]](#note2)</sup>} in 0.8.0 | [PR #1677](https://github.com/dash/dash/pull/1677)
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index 12e1ee4bacba8..69fcb5464e71c 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -198,17 +198,16 @@ bool CBanDB::Write(const banmap_t& banSet)
     return false;
 }
 
-bool CBanDB::Read(banmap_t& banSet, bool& dirty)
+bool CBanDB::Read(banmap_t& banSet)
 {
-    // If the JSON banlist does not exist, then try to read the non-upgraded banlist.dat.
+    if (fs::exists(m_banlist_dat)) {
+        LogPrintf("banlist.dat ignored because it can only be read by " PACKAGE_NAME " version 19.x. Remove %s to silence this warning.\n", m_banlist_dat);
+    }
+    // If the JSON banlist does not exist, then recreate it
     if (!fs::exists(m_banlist_json)) {
-        // If this succeeds then we need to flush to disk in order to create the JSON banlist.
-        dirty = true;
-        return DeserializeFileDB(m_banlist_dat, banSet, CLIENT_VERSION);
+        return false;
     }
 
-    dirty = false;
-
     std::map<std::string, util::SettingsValue> settings;
     std::vector<std::string> errors;
 
diff --git a/src/addrdb.h b/src/addrdb.h
index 88dec7db51f89..9abe4cc769f3a 100644
--- a/src/addrdb.h
+++ b/src/addrdb.h
@@ -76,7 +76,7 @@ class CAddrDB
     static bool Read(CAddrMan& addr, CDataStream& ssPeers);
 };
 
-/** Access to the banlist databases (banlist.json and banlist.dat) */
+/** Access to the banlist database (banlist.json) */
 class CBanDB
 {
 private:
@@ -95,11 +95,9 @@ class CBanDB
      * Read the banlist from disk.
      * @param[out] banSet The loaded list. Set if `true` is returned, otherwise it is left
      * in an undefined state.
-     * @param[out] dirty Indicates whether the loaded list needs flushing to disk. Set if
-     * `true` is returned, otherwise it is left in an undefined state.
      * @return true on success
      */
-    bool Read(banmap_t& banSet, bool& dirty);
+    bool Read(banmap_t& banSet);
 };
 
 /**
diff --git a/src/banman.cpp b/src/banman.cpp
index ba1db1157791a..9599c41e2e221 100644
--- a/src/banman.cpp
+++ b/src/banman.cpp
@@ -18,7 +18,7 @@ BanMan::BanMan(fs::path ban_file, CClientUIInterface* client_interface, int64_t
     if (m_client_interface) m_client_interface->InitMessage(_("Loading banlist...").translated);
 
     int64_t n_start = GetTimeMillis();
-    if (m_ban_db.Read(m_banned, m_is_dirty)) {
+    if (m_ban_db.Read(m_banned)) {
         SweepBanned(); // sweep out unused entries
 
         LogPrint(BCLog::NET, "Loaded %d banned node addresses/subnets  %dms\n", m_banned.size(),
diff --git a/src/banman.h b/src/banman.h
index 06f18ea826c0d..956729e497860 100644
--- a/src/banman.h
+++ b/src/banman.h
@@ -89,7 +89,7 @@ class BanMan
 
     RecursiveMutex m_cs_banned;
     banmap_t m_banned GUARDED_BY(m_cs_banned);
-    bool m_is_dirty GUARDED_BY(m_cs_banned);
+    bool m_is_dirty GUARDED_BY(m_cs_banned){false};
     CClientUIInterface* m_client_interface = nullptr;
     CBanDB m_ban_db;
     const int64_t m_default_ban_time;
diff --git a/src/netaddress.h b/src/netaddress.h
index a2b8418ad4e95..87fbb39efe849 100644
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -41,8 +41,7 @@ static constexpr int ADDRV2_FORMAT = 0x20000000;
  * over all enum values and also `GetExtNetwork()` "extends" this enum by
  * introducing standalone constants starting from `NET_MAX`.
  */
-enum Network
-{
+enum Network {
     /// Addresses from these networks are not publicly routable on the global Internet.
     NET_UNROUTABLE = 0,
 
@@ -72,16 +71,14 @@ enum Network
 /// Prefix of an IPv6 address when it contains an embedded IPv4 address.
 /// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
 static const std::array<uint8_t, 12> IPV4_IN_IPV6_PREFIX{
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF
-};
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF};
 
 /// Prefix of an IPv6 address when it contains an embedded TORv2 address.
 /// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
 /// Such dummy IPv6 addresses are guaranteed to not be publicly routable as they
 /// fall under RFC4193's fc00::/7 subnet allocated to unique-local addresses.
 static const std::array<uint8_t, 6> TORV2_IN_IPV6_PREFIX{
-    0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43
-};
+    0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43};
 
 /// Prefix of an IPv6 address when it contains an embedded "internal" address.
 /// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
@@ -119,455 +116,438 @@ static constexpr uint16_t I2P_SAM31_PORT{0};
  */
 class CNetAddr
 {
-    protected:
-        /**
-         * Raw representation of the network address.
-         * In network byte order (big endian) for IPv4 and IPv6.
-         */
-        prevector<ADDR_IPV6_SIZE, uint8_t> m_addr{ADDR_IPV6_SIZE, 0x0};
-
-        /**
-         * Network to which this address belongs.
-         */
-        Network m_net{NET_IPV6};
-
-        /**
-         * Scope id if scoped/link-local IPV6 address.
-         * See https://tools.ietf.org/html/rfc4007
-         */
-        uint32_t m_scope_id{0};
-
-    public:
-        CNetAddr();
-        explicit CNetAddr(const struct in_addr& ipv4Addr);
-        void SetIP(const CNetAddr& ip);
-
-        /**
-         * Set from a legacy IPv6 address.
-         * Legacy IPv6 address may be a normal IPv6 address, or another address
-         * (e.g. IPv4) disguised as IPv6. This encoding is used in the legacy
-         * `addr` encoding.
-         */
-        void SetLegacyIPv6(Span<const uint8_t> ipv6);
-
-        /**
-         * Set raw IPv4 or IPv6 address (in network byte order)
-         * @note Only NET_IPV4 and NET_IPV6 are allowed for network.
-         */
-        void SetRaw(Network network, const uint8_t *data);
-
-    public:
-        bool SetInternal(const std::string& name);
-
-        /**
-         * Parse a Tor or I2P address and set this object to it.
-         * @param[in] addr Address to parse, for example
-         * pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion or
-         * ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
-         * @returns Whether the operation was successful.
-         * @see CNetAddr::IsTor(), CNetAddr::IsI2P()
-         */
-        bool SetSpecial(const std::string& addr);
-
-        bool IsBindAny() const; // INADDR_ANY equivalent
-        bool IsIPv4() const;    // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
-        bool IsIPv6() const;    // IPv6 address (not mapped IPv4, not Tor)
-        bool IsRFC1918() const; // IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
-        bool IsRFC2544() const; // IPv4 inter-network communications (198.18.0.0/15)
-        bool IsRFC6598() const; // IPv4 ISP-level NAT (100.64.0.0/10)
-        bool IsRFC5737() const; // IPv4 documentation addresses (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24)
-        bool IsRFC3849() const; // IPv6 documentation address (2001:0DB8::/32)
-        bool IsRFC3927() const; // IPv4 autoconfig (169.254.0.0/16)
-        bool IsRFC3964() const; // IPv6 6to4 tunnelling (2002::/16)
-        bool IsRFC4193() const; // IPv6 unique local (FC00::/7)
-        bool IsRFC4380() const; // IPv6 Teredo tunnelling (2001::/32)
-        bool IsRFC4843() const; // IPv6 ORCHID (deprecated) (2001:10::/28)
-        bool IsRFC7343() const; // IPv6 ORCHIDv2 (2001:20::/28)
-        bool IsRFC4862() const; // IPv6 autoconfig (FE80::/64)
-        bool IsRFC6052() const; // IPv6 well-known prefix for IPv4-embedded address (64:FF9B::/96)
-        bool IsRFC6145() const; // IPv6 IPv4-translated address (::FFFF:0:0:0/96) (actually defined in RFC2765)
-        bool IsHeNet() const;   // IPv6 Hurricane Electric - https://he.net (2001:0470::/36)
-        bool IsTor() const;
-        bool IsI2P() const;
-        bool IsCJDNS() const;
-        bool IsLocal() const;
-        bool IsRoutable() const;
-        bool IsInternal() const;
-        bool IsValid() const;
-
-        /**
-         * Check if the current object can be serialized in pre-ADDRv2/BIP155 format.
-         */
-        bool IsAddrV1Compatible() const;
-
-        enum Network GetNetwork() const;
-        std::string ToString() const;
-        std::string ToStringIP(bool fUseGetnameinfo = true) const;
-        uint64_t GetHash() const;
-        bool GetInAddr(struct in_addr* pipv4Addr) const;
-        Network GetNetClass() const;
-
-        //! For IPv4, mapped IPv4, SIIT translated IPv4, Teredo, 6to4 tunneled addresses, return the relevant IPv4 address as a uint32.
-        uint32_t GetLinkedIPv4() const;
-        //! Whether this address has a linked IPv4 address (see GetLinkedIPv4()).
-        bool HasLinkedIPv4() const;
-
-        // The AS on the BGP path to the node we use to diversify
-        // peers in AddrMan bucketing based on the AS infrastructure.
-        // The ip->AS mapping depends on how asmap is constructed.
-        uint32_t GetMappedAS(const std::vector<bool> &asmap) const;
-        std::vector<unsigned char> GetGroup(const std::vector<bool> &asmap) const;
-        std::vector<unsigned char> GetAddrBytes() const;
-        int GetReachabilityFrom(const CNetAddr *paddrPartner = nullptr) const;
-
-        explicit CNetAddr(const struct in6_addr& pipv6Addr, const uint32_t scope = 0);
-        bool GetIn6Addr(struct in6_addr* pipv6Addr) const;
-
-        friend bool operator==(const CNetAddr& a, const CNetAddr& b);
-        friend bool operator!=(const CNetAddr& a, const CNetAddr& b) { return !(a == b); }
-        friend bool operator<(const CNetAddr& a, const CNetAddr& b);
-
-        /**
-         * Serialize to a stream.
-         */
-        template <typename Stream>
-        void Serialize(Stream& s) const
-        {
-            if (s.GetVersion() & ADDRV2_FORMAT) {
-                SerializeV2Stream(s);
-            } else {
-                SerializeV1Stream(s);
-            }
+protected:
+    /**
+     * Raw representation of the network address.
+     * In network byte order (big endian) for IPv4 and IPv6.
+     */
+    prevector<ADDR_IPV6_SIZE, uint8_t> m_addr{ADDR_IPV6_SIZE, 0x0};
+
+    /**
+     * Network to which this address belongs.
+     */
+    Network m_net{NET_IPV6};
+
+    /**
+     * Scope id if scoped/link-local IPV6 address.
+     * See https://tools.ietf.org/html/rfc4007
+     */
+    uint32_t m_scope_id{0};
+
+public:
+    CNetAddr();
+    explicit CNetAddr(const struct in_addr& ipv4Addr);
+    void SetIP(const CNetAddr& ip);
+
+    /**
+     * Set from a legacy IPv6 address.
+     * Legacy IPv6 address may be a normal IPv6 address, or another address
+     * (e.g. IPv4) disguised as IPv6. This encoding is used in the legacy
+     * `addr` encoding.
+     */
+    void SetLegacyIPv6(Span<const uint8_t> ipv6);
+
+    /**
+     * Set raw IPv4 or IPv6 address (in network byte order)
+     * @note Only NET_IPV4 and NET_IPV6 are allowed for network.
+     */
+    void SetRaw(Network network, const uint8_t *data);
+
+public:
+    bool SetInternal(const std::string& name);
+
+    /**
+     * Parse a Tor or I2P address and set this object to it.
+     * @param[in] addr Address to parse, for example
+     * pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion or
+     * ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
+     * @returns Whether the operation was successful.
+     * @see CNetAddr::IsTor(), CNetAddr::IsI2P()
+     */
+    bool SetSpecial(const std::string& addr);
+
+    bool IsBindAny() const; // INADDR_ANY equivalent
+    bool IsIPv4() const;    // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
+    bool IsIPv6() const;    // IPv6 address (not mapped IPv4, not Tor)
+    bool IsRFC1918() const; // IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
+    bool IsRFC2544() const; // IPv4 inter-network communications (198.18.0.0/15)
+    bool IsRFC6598() const; // IPv4 ISP-level NAT (100.64.0.0/10)
+    bool IsRFC5737() const; // IPv4 documentation addresses (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24)
+    bool IsRFC3849() const; // IPv6 documentation address (2001:0DB8::/32)
+    bool IsRFC3927() const; // IPv4 autoconfig (169.254.0.0/16)
+    bool IsRFC3964() const; // IPv6 6to4 tunnelling (2002::/16)
+    bool IsRFC4193() const; // IPv6 unique local (FC00::/7)
+    bool IsRFC4380() const; // IPv6 Teredo tunnelling (2001::/32)
+    bool IsRFC4843() const; // IPv6 ORCHID (deprecated) (2001:10::/28)
+    bool IsRFC7343() const; // IPv6 ORCHIDv2 (2001:20::/28)
+    bool IsRFC4862() const; // IPv6 autoconfig (FE80::/64)
+    bool IsRFC6052() const; // IPv6 well-known prefix for IPv4-embedded address (64:FF9B::/96)
+    bool IsRFC6145() const; // IPv6 IPv4-translated address (::FFFF:0:0:0/96) (actually defined in RFC2765)
+    bool IsHeNet() const;   // IPv6 Hurricane Electric - https://he.net (2001:0470::/36)
+    bool IsTor() const;
+    bool IsI2P() const;
+    bool IsCJDNS() const;
+    bool IsLocal() const;
+    bool IsRoutable() const;
+    bool IsInternal() const;
+    bool IsValid() const;
+
+    /**
+     * Check if the current object can be serialized in pre-ADDRv2/BIP155 format.
+     */
+    bool IsAddrV1Compatible() const;
+
+    enum Network GetNetwork() const;
+    std::string ToString() const;
+    std::string ToStringIP(bool fUseGetnameinfo = true) const;
+    uint64_t GetHash() const;
+    bool GetInAddr(struct in_addr* pipv4Addr) const;
+    Network GetNetClass() const;
+
+    //! For IPv4, mapped IPv4, SIIT translated IPv4, Teredo, 6to4 tunneled addresses, return the relevant IPv4 address as a uint32.
+    uint32_t GetLinkedIPv4() const;
+    //! Whether this address has a linked IPv4 address (see GetLinkedIPv4()).
+    bool HasLinkedIPv4() const;
+
+    // The AS on the BGP path to the node we use to diversify
+    // peers in AddrMan bucketing based on the AS infrastructure.
+    // The ip->AS mapping depends on how asmap is constructed.
+    uint32_t GetMappedAS(const std::vector<bool> &asmap) const;
+
+    std::vector<unsigned char> GetGroup(const std::vector<bool> &asmap) const;
+    std::vector<unsigned char> GetAddrBytes() const;
+    int GetReachabilityFrom(const CNetAddr *paddrPartner = nullptr) const;
+
+    explicit CNetAddr(const struct in6_addr& pipv6Addr, const uint32_t scope = 0);
+    bool GetIn6Addr(struct in6_addr* pipv6Addr) const;
+
+    friend bool operator==(const CNetAddr& a, const CNetAddr& b);
+    friend bool operator!=(const CNetAddr& a, const CNetAddr& b) { return !(a == b); }
+    friend bool operator<(const CNetAddr& a, const CNetAddr& b);
+
+    /**
+     * Serialize to a stream.
+     */
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        if (s.GetVersion() & ADDRV2_FORMAT) {
+            SerializeV2Stream(s);
+        } else {
+            SerializeV1Stream(s);
         }
-
-        /**
-         * Unserialize from a stream.
-         */
-        template <typename Stream>
-        void Unserialize(Stream& s)
-        {
-            if (s.GetVersion() & ADDRV2_FORMAT) {
-                UnserializeV2Stream(s);
-            } else {
-                UnserializeV1Stream(s);
-            }
+    }
+
+    /**
+     * Unserialize from a stream.
+     */
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        if (s.GetVersion() & ADDRV2_FORMAT) {
+            UnserializeV2Stream(s);
+        } else {
+            UnserializeV1Stream(s);
         }
-
-        friend class CSubNet;
-
-    private:
-        /**
-         * Parse a Tor address and set this object to it.
-         * @param[in] addr Address to parse, must be a valid C string, for example
-         * pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.
-         * @returns Whether the operation was successful.
-         * @see CNetAddr::IsTor()
-         */
-        bool SetTor(const std::string& addr);
-
-        /**
-         * Parse an I2P address and set this object to it.
-         * @param[in] addr Address to parse, must be a valid C string, for example
-         * ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
-         * @returns Whether the operation was successful.
-         * @see CNetAddr::IsI2P()
-         */
-        bool SetI2P(const std::string& addr);
-
-        /**
-         * BIP155 network ids recognized by this software.
-         */
-        enum BIP155Network : uint8_t {
-            IPV4 = 1,
-            IPV6 = 2,
-            TORV2 = 3,
-            TORV3 = 4,
-            I2P = 5,
-            CJDNS = 6,
-        };
-
-        /**
-         * Size of CNetAddr when serialized as ADDRv1 (pre-BIP155) (in bytes).
-         */
-        static constexpr size_t V1_SERIALIZATION_SIZE = ADDR_IPV6_SIZE;
-
-        /**
-         * Maximum size of an address as defined in BIP155 (in bytes).
-         * This is only the size of the address, not the entire CNetAddr object
-         * when serialized.
-         */
-        static constexpr size_t MAX_ADDRV2_SIZE = 512;
-
-        /**
-         * Get the BIP155 network id of this address.
-         * Must not be called for IsInternal() objects.
-         * @returns BIP155 network id, except TORV2 which is no longer supported.
-         */
-        BIP155Network GetBIP155Network() const;
-
-        /**
-         * Set `m_net` from the provided BIP155 network id and size after validation.
-         * @retval true the network was recognized, is valid and `m_net` was set
-         * @retval false not recognised (from future?) and should be silently ignored
-         * @throws std::ios_base::failure if the network is one of the BIP155 founding
-         * networks (id 1..6) with wrong address size.
-         */
-        bool SetNetFromBIP155Network(uint8_t possible_bip155_net, size_t address_size);
-
-        /**
-         * Serialize in pre-ADDRv2/BIP155 format to an array.
-         */
-        void SerializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) const
-        {
-            size_t prefix_size;
-
-            switch (m_net) {
-            case NET_IPV6:
-                assert(m_addr.size() == sizeof(arr));
-                memcpy(arr, m_addr.data(), m_addr.size());
-                return;
-            case NET_IPV4:
-                prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
-                assert(prefix_size + m_addr.size() == sizeof(arr));
-                memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
-                memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
-                return;
-            case NET_INTERNAL:
-                prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
-                assert(prefix_size + m_addr.size() == sizeof(arr));
-                memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
-                memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
-                return;
-            case NET_ONION:
-            case NET_I2P:
-            case NET_CJDNS:
-                break;
-            case NET_UNROUTABLE:
-            case NET_MAX:
-                assert(false);
-            } // no default case, so the compiler can warn about missing cases
-
-            // Serialize ONION, I2P and CJDNS as all-zeros.
-            memset(arr, 0x0, V1_SERIALIZATION_SIZE);
+    }
+
+    friend class CSubNet;
+
+private:
+    /**
+     * Parse a Tor address and set this object to it.
+     * @param[in] addr Address to parse, must be a valid C string, for example
+     * pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.
+     * @returns Whether the operation was successful.
+     * @see CNetAddr::IsTor()
+     */
+    bool SetTor(const std::string& addr);
+
+    /**
+     * Parse an I2P address and set this object to it.
+     * @param[in] addr Address to parse, must be a valid C string, for example
+     * ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
+     * @returns Whether the operation was successful.
+     * @see CNetAddr::IsI2P()
+     */
+    bool SetI2P(const std::string& addr);
+
+    /**
+     * BIP155 network ids recognized by this software.
+     */
+    enum BIP155Network : uint8_t {
+        IPV4 = 1,
+        IPV6 = 2,
+        TORV2 = 3,
+        TORV3 = 4,
+        I2P = 5,
+        CJDNS = 6,
+    };
+
+    /**
+     * Size of CNetAddr when serialized as ADDRv1 (pre-BIP155) (in bytes).
+     */
+    static constexpr size_t V1_SERIALIZATION_SIZE = ADDR_IPV6_SIZE;
+
+    /**
+     * Maximum size of an address as defined in BIP155 (in bytes).
+     * This is only the size of the address, not the entire CNetAddr object
+     * when serialized.
+     */
+    static constexpr size_t MAX_ADDRV2_SIZE = 512;
+
+    /**
+     * Get the BIP155 network id of this address.
+     * Must not be called for IsInternal() objects.
+     * @returns BIP155 network id, except TORV2 which is no longer supported.
+     */
+    BIP155Network GetBIP155Network() const;
+
+    /**
+     * Set `m_net` from the provided BIP155 network id and size after validation.
+     * @retval true the network was recognized, is valid and `m_net` was set
+     * @retval false not recognised (from future?) and should be silently ignored
+     * @throws std::ios_base::failure if the network is one of the BIP155 founding
+     * networks (id 1..6) with wrong address size.
+     */
+    bool SetNetFromBIP155Network(uint8_t possible_bip155_net, size_t address_size);
+
+    /**
+     * Serialize in pre-ADDRv2/BIP155 format to an array.
+     */
+    void SerializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) const
+    {
+        size_t prefix_size;
+
+        switch (m_net) {
+        case NET_IPV6:
+            assert(m_addr.size() == sizeof(arr));
+            memcpy(arr, m_addr.data(), m_addr.size());
+            return;
+        case NET_IPV4:
+            prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
+            assert(prefix_size + m_addr.size() == sizeof(arr));
+            memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
+            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
+            return;
+        case NET_INTERNAL:
+            prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
+            assert(prefix_size + m_addr.size() == sizeof(arr));
+            memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
+            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
+            return;
+        case NET_ONION:
+        case NET_I2P:
+        case NET_CJDNS:
+            break;
+        case NET_UNROUTABLE:
+        case NET_MAX:
+            assert(false);
+        } // no default case, so the compiler can warn about missing cases
+
+        // Serialize ONION, I2P and CJDNS as all-zeros.
+        memset(arr, 0x0, V1_SERIALIZATION_SIZE);
+    }
+
+public:
+    /**
+     * Serialize in pre-ADDRv2/BIP155 format to a stream.
+     */
+    template <typename Stream>
+    void SerializeV1Stream(Stream& s) const
+    {
+        uint8_t serialized[V1_SERIALIZATION_SIZE];
+
+        SerializeV1Array(serialized);
+
+        s << serialized;
+    }
+
+    /**
+     * Serialize as ADDRv2 / BIP155.
+     */
+    template <typename Stream>
+    void SerializeV2Stream(Stream& s) const
+    {
+        if (IsInternal()) {
+            // Serialize NET_INTERNAL as embedded in IPv6. We need to
+            // serialize such addresses from addrman.
+            s << static_cast<uint8_t>(BIP155Network::IPV6);
+            s << COMPACTSIZE(ADDR_IPV6_SIZE);
+            SerializeV1Stream(s);
+            return;
         }
 
-    public:
-        /**
-         * Serialize in pre-ADDRv2/BIP155 format to a stream.
-         */
-        template <typename Stream>
-        void SerializeV1Stream(Stream& s) const
-        {
-            uint8_t serialized[V1_SERIALIZATION_SIZE];
+        s << static_cast<uint8_t>(GetBIP155Network());
+        s << m_addr;
+    }
+
+    /**
+     * Unserialize from a pre-ADDRv2/BIP155 format from an array.
+     */
+    void UnserializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE])
+    {
+        // Use SetLegacyIPv6() so that m_net is set correctly. For example
+        // ::FFFF:0102:0304 should be set as m_net=NET_IPV4 (1.2.3.4).
+        SetLegacyIPv6(arr);
+    }
+
+    /**
+     * Unserialize from a pre-ADDRv2/BIP155 format from a stream.
+     */
+    template <typename Stream>
+    void UnserializeV1Stream(Stream& s)
+    {
+        uint8_t serialized[V1_SERIALIZATION_SIZE];
+
+        s >> serialized;
+
+        UnserializeV1Array(serialized);
+    }
+
+    /**
+     * Unserialize from a ADDRv2 / BIP155 format.
+     */
+    template <typename Stream>
+    void UnserializeV2Stream(Stream& s)
+    {
+        uint8_t bip155_net;
+        s >> bip155_net;
+
+        size_t address_size;
+        s >> COMPACTSIZE(address_size);
+
+        if (address_size > MAX_ADDRV2_SIZE) {
+            throw std::ios_base::failure(strprintf(
+                "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
+        }
 
-            SerializeV1Array(serialized);
+        m_scope_id = 0;
 
-            s << serialized;
-        }
+        if (SetNetFromBIP155Network(bip155_net, address_size)) {
+            m_addr.resize(address_size);
+            s >> MakeSpan(m_addr);
 
-        /**
-         * Serialize as ADDRv2 / BIP155.
-         */
-        template <typename Stream>
-        void SerializeV2Stream(Stream& s) const
-        {
-            if (IsInternal()) {
-                // Serialize NET_INTERNAL as embedded in IPv6. We need to
-                // serialize such addresses from addrman.
-                s << static_cast<uint8_t>(BIP155Network::IPV6);
-                s << COMPACTSIZE(ADDR_IPV6_SIZE);
-                SerializeV1Stream(s);
+            if (m_net != NET_IPV6) {
                 return;
             }
 
-            s << static_cast<uint8_t>(GetBIP155Network());
-            s << m_addr;
-        }
+            // Do some special checks on IPv6 addresses.
 
-        /**
-         * Unserialize from a pre-ADDRv2/BIP155 format from an array.
-         */
-        void UnserializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE])
-        {
-            // Use SetLegacyIPv6() so that m_net is set correctly. For example
-            // ::FFFF:0102:0304 should be set as m_net=NET_IPV4 (1.2.3.4).
-            SetLegacyIPv6(arr);
-        }
-
-        /**
-         * Unserialize from a pre-ADDRv2/BIP155 format from a stream.
-         */
-        template <typename Stream>
-        void UnserializeV1Stream(Stream& s)
-        {
-            uint8_t serialized[V1_SERIALIZATION_SIZE];
-
-            s >> serialized;
-
-            UnserializeV1Array(serialized);
-        }
-
-        /**
-         * Unserialize from a ADDRv2 / BIP155 format.
-         */
-        template <typename Stream>
-        void UnserializeV2Stream(Stream& s)
-        {
-            uint8_t bip155_net;
-            s >> bip155_net;
-
-            size_t address_size;
-            s >> COMPACTSIZE(address_size);
-
-            if (address_size > MAX_ADDRV2_SIZE) {
-                throw std::ios_base::failure(strprintf(
-                    "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
+            // Recognize NET_INTERNAL embedded in IPv6, such addresses are not
+            // gossiped but could be coming from addrman, when unserializing from
+            // disk.
+            if (HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
+                m_net = NET_INTERNAL;
+                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
+                        ADDR_INTERNAL_SIZE);
+                m_addr.resize(ADDR_INTERNAL_SIZE);
+                return;
             }
 
-            m_scope_id = 0;
-
-            if (SetNetFromBIP155Network(bip155_net, address_size)) {
-                m_addr.resize(address_size);
-                s >> MakeSpan(m_addr);
-
-                if (m_net != NET_IPV6) {
-                    return;
-                }
-
-                // Do some special checks on IPv6 addresses.
-
-                // Recognize NET_INTERNAL embedded in IPv6, such addresses are not
-                // gossiped but could be coming from addrman, when unserializing from
-                // disk.
-                if (HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
-                    m_net = NET_INTERNAL;
-                    memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
-                            ADDR_INTERNAL_SIZE);
-                    m_addr.resize(ADDR_INTERNAL_SIZE);
-                    return;
-                }
-
-                if (!HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
-                    !HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
-                    return;
-                }
-
-                // IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in V1
-                // encoding). Unserialize as !IsValid(), thus ignoring them.
-            } else {
-                // If we receive an unknown BIP155 network id (from the future?) then
-                // ignore the address - unserialize as !IsValid().
-                s.ignore(address_size);
+            if (!HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
+                !HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
+                return;
             }
 
-            // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
-            // will not be gossiped, but continue reading next addresses from the stream.
-            m_net = NET_IPV6;
-            m_addr.assign(ADDR_IPV6_SIZE, 0x0);
+            // IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in V1
+            // encoding). Unserialize as !IsValid(), thus ignoring them.
+        } else {
+            // If we receive an unknown BIP155 network id (from the future?) then
+            // ignore the address - unserialize as !IsValid().
+            s.ignore(address_size);
         }
+
+        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
+        // will not be gossiped, but continue reading next addresses from the stream.
+        m_net = NET_IPV6;
+        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
+    }
 };
 
 class CSubNet
 {
-    protected:
-        /// Network (base) address
-        CNetAddr network;
-        /// Netmask, in network byte order
-        uint8_t netmask[16];
-        /// Is this value valid? (only used to signal parse errors)
-        bool valid;
-
-        bool SanityCheck() const;
-
-    public:
-        /**
-         * Construct an invalid subnet (empty, `Match()` always returns false).
-         */
-        CSubNet();
-
-        /**
-         * Construct from a given network start and number of bits (CIDR mask).
-         * @param[in] addr Network start. Must be IPv4 or IPv6, otherwise an invalid subnet is
-         * created.
-         * @param[in] mask CIDR mask, must be in [0, 32] for IPv4 addresses and in [0, 128] for
-         * IPv6 addresses. Otherwise an invalid subnet is created.
-         */
-        CSubNet(const CNetAddr& addr, uint8_t mask);
-
-        /**
-         * Construct from a given network start and mask.
-         * @param[in] addr Network start. Must be IPv4 or IPv6, otherwise an invalid subnet is
-         * created.
-         * @param[in] mask Network mask, must be of the same type as `addr` and not contain 0-bits
-         * followed by 1-bits. Otherwise an invalid subnet is created.
-         */
-        CSubNet(const CNetAddr& addr, const CNetAddr& mask);
-
-        /**
-         * Construct a single-host subnet.
-         * @param[in] addr The sole address to be contained in the subnet, can also be non-IPv[46].
-         */
-        explicit CSubNet(const CNetAddr& addr);
-
-        bool Match(const CNetAddr &addr) const;
-
-        std::string ToString() const;
-        bool IsValid() const;
-
-        friend bool operator==(const CSubNet& a, const CSubNet& b);
-        friend bool operator!=(const CSubNet& a, const CSubNet& b) { return !(a == b); }
-        friend bool operator<(const CSubNet& a, const CSubNet& b);
-
-        SERIALIZE_METHODS(CSubNet, obj)
-        {
-            READWRITE(obj.network);
-            if (obj.network.IsIPv4()) {
-                // Before commit 102867c587f5f7954232fb8ed8e85cda78bb4d32, CSubNet used the last 4 bytes of netmask
-                // to store the relevant bytes for an IPv4 mask. For compatibility reasons, keep doing so in
-                // serialized form.
-                unsigned char dummy[12] = {0};
-                READWRITE(dummy);
-                READWRITE(MakeSpan(obj.netmask).first(4));
-            } else {
-                READWRITE(obj.netmask);
-            }
-            READWRITE(obj.valid);
-            // Mark invalid if the result doesn't pass sanity checking.
-            SER_READ(obj, if (obj.valid) obj.valid = obj.SanityCheck());
-        }
+protected:
+    /// Network (base) address
+    CNetAddr network;
+    /// Netmask, in network byte order
+    uint8_t netmask[16];
+    /// Is this value valid? (only used to signal parse errors)
+    bool valid;
+
+    bool SanityCheck() const;
+
+public:
+    /**
+     * Construct an invalid subnet (empty, `Match()` always returns false).
+     */
+    CSubNet();
+
+    /**
+     * Construct from a given network start and number of bits (CIDR mask).
+     * @param[in] addr Network start. Must be IPv4 or IPv6, otherwise an invalid subnet is
+     * created.
+     * @param[in] mask CIDR mask, must be in [0, 32] for IPv4 addresses and in [0, 128] for
+     * IPv6 addresses. Otherwise an invalid subnet is created.
+     */
+    CSubNet(const CNetAddr& addr, uint8_t mask);
+
+    /**
+     * Construct from a given network start and mask.
+     * @param[in] addr Network start. Must be IPv4 or IPv6, otherwise an invalid subnet is
+     * created.
+     * @param[in] mask Network mask, must be of the same type as `addr` and not contain 0-bits
+     * followed by 1-bits. Otherwise an invalid subnet is created.
+     */
+    CSubNet(const CNetAddr& addr, const CNetAddr& mask);
+
+    /**
+     * Construct a single-host subnet.
+     * @param[in] addr The sole address to be contained in the subnet, can also be non-IPv[46].
+     */
+    explicit CSubNet(const CNetAddr& addr);
+
+    bool Match(const CNetAddr &addr) const;
+
+    std::string ToString() const;
+    bool IsValid() const;
+
+    friend bool operator==(const CSubNet& a, const CSubNet& b);
+    friend bool operator!=(const CSubNet& a, const CSubNet& b) { return !(a == b); }
+    friend bool operator<(const CSubNet& a, const CSubNet& b);
 };
 
 /** A combination of a network address (CNetAddr) and a (TCP) port */
 class CService : public CNetAddr
 {
-    protected:
-        uint16_t port; // host order
-
-    public:
-        CService();
-        CService(const CNetAddr& ip, uint16_t port);
-        CService(const struct in_addr& ipv4Addr, uint16_t port);
-        explicit CService(const struct sockaddr_in& addr);
-        void SetPort(uint16_t portIn);
-        uint16_t GetPort() const;
-        bool GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const;
-        bool SetSockAddr(const struct sockaddr* paddr);
-        friend bool operator==(const CService& a, const CService& b);
-        friend bool operator!=(const CService& a, const CService& b) { return !(a == b); }
-        friend bool operator<(const CService& a, const CService& b);
-        std::vector<unsigned char> GetKey() const;
-        std::string ToString(bool fUseGetnameinfo = true) const;
-        std::string ToStringPort() const;
-        std::string ToStringIPPort(bool fUseGetnameinfo = true) const;
-
-        CService(const struct in6_addr& ipv6Addr, uint16_t port);
-        explicit CService(const struct sockaddr_in6& addr);
-
-        SERIALIZE_METHODS(CService, obj)
-        {
-            READWRITEAS(CNetAddr, obj);
-            READWRITE(Using<BigEndianFormatter<2>>(obj.port));
-        }
+protected:
+    uint16_t port; // host order
+
+public:
+    CService();
+    CService(const CNetAddr& ip, uint16_t port);
+    CService(const struct in_addr& ipv4Addr, uint16_t port);
+    explicit CService(const struct sockaddr_in& addr);
+    void SetPort(uint16_t portIn);
+    uint16_t GetPort() const;
+    bool GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const;
+    bool SetSockAddr(const struct sockaddr* paddr);
+    friend bool operator==(const CService& a, const CService& b);
+    friend bool operator!=(const CService& a, const CService& b) { return !(a == b); }
+    friend bool operator<(const CService& a, const CService& b);
+    std::vector<unsigned char> GetKey() const;
+    std::string ToString(bool fUseGetnameinfo = true) const;
+    std::string ToStringPort() const;
+    std::string ToStringIPPort(bool fUseGetnameinfo = true) const;
+
+    CService(const struct in6_addr& ipv6Addr, uint16_t port);
+    explicit CService(const struct sockaddr_in6& addr);
+
+    SERIALIZE_METHODS(CService, obj)
+    {
+        READWRITEAS(CNetAddr, obj);
+        READWRITE(Using<BigEndianFormatter<2>>(obj.port));
+    }
 };
 
 bool SanityCheckASMap(const std::vector<bool>& asmap);
diff --git a/src/test/fuzz/banman.cpp b/src/test/fuzz/banman.cpp
index 5fd53b2d58c65..5540ee14f2a56 100644
--- a/src/test/fuzz/banman.cpp
+++ b/src/test/fuzz/banman.cpp
@@ -43,8 +43,7 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
 
     const bool start_with_corrupted_banlist{fuzzed_data_provider.ConsumeBool()};
     if (start_with_corrupted_banlist) {
-        const std::string sfx{fuzzed_data_provider.ConsumeBool() ? ".dat" : ".json"};
-        assert(WriteBinaryFile(banlist_file.string() + sfx,
+        assert(WriteBinaryFile(banlist_file.string() + ".json",
                                fuzzed_data_provider.ConsumeRandomLengthString()));
     } else {
         const bool force_read_and_write_to_err{fuzzed_data_provider.ConsumeBool()};
@@ -93,6 +92,5 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
                 });
         }
     }
-    fs::remove(banlist_file.string() + ".dat");
     fs::remove(banlist_file.string() + ".json");
 }
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index 39ed4d464afd6..7a90d9d79d2a5 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -100,231 +100,220 @@ void AssertEqualAfterSerializeDeserialize(const T& obj, const int version = INIT
 
 /*
 FUZZ_TARGET_DESERIALIZE(block_filter_deserialize, {
-        BlockFilter block_filter;
-        DeserializeFromFuzzingInput(buffer, block_filter);
+    BlockFilter block_filter;
+    DeserializeFromFuzzingInput(buffer, block_filter);
 })
 */
 FUZZ_TARGET_DESERIALIZE(addr_info_deserialize, {
-        CAddrInfo addr_info;
-        DeserializeFromFuzzingInput(buffer, addr_info);
+    CAddrInfo addr_info;
+    DeserializeFromFuzzingInput(buffer, addr_info);
 })
 FUZZ_TARGET_DESERIALIZE(block_file_info_deserialize, {
-        CBlockFileInfo block_file_info;
-        DeserializeFromFuzzingInput(buffer, block_file_info);
+    CBlockFileInfo block_file_info;
+    DeserializeFromFuzzingInput(buffer, block_file_info);
 })
 FUZZ_TARGET_DESERIALIZE(block_header_and_short_txids_deserialize, {
-        CBlockHeaderAndShortTxIDs block_header_and_short_txids;
-        DeserializeFromFuzzingInput(buffer, block_header_and_short_txids);
+    CBlockHeaderAndShortTxIDs block_header_and_short_txids;
+    DeserializeFromFuzzingInput(buffer, block_header_and_short_txids);
 })
 FUZZ_TARGET_DESERIALIZE(fee_rate_deserialize, {
-        CFeeRate fee_rate;
-        DeserializeFromFuzzingInput(buffer, fee_rate);
-        AssertEqualAfterSerializeDeserialize(fee_rate);
+    CFeeRate fee_rate;
+    DeserializeFromFuzzingInput(buffer, fee_rate);
+    AssertEqualAfterSerializeDeserialize(fee_rate);
 })
 FUZZ_TARGET_DESERIALIZE(merkle_block_deserialize, {
-        CMerkleBlock merkle_block;
-        DeserializeFromFuzzingInput(buffer, merkle_block);
+    CMerkleBlock merkle_block;
+    DeserializeFromFuzzingInput(buffer, merkle_block);
 })
 FUZZ_TARGET_DESERIALIZE(out_point_deserialize, {
-        COutPoint out_point;
-        DeserializeFromFuzzingInput(buffer, out_point);
-        AssertEqualAfterSerializeDeserialize(out_point);
+    COutPoint out_point;
+    DeserializeFromFuzzingInput(buffer, out_point);
+    AssertEqualAfterSerializeDeserialize(out_point);
 })
 FUZZ_TARGET_DESERIALIZE(partial_merkle_tree_deserialize, {
-        CPartialMerkleTree partial_merkle_tree;
-        DeserializeFromFuzzingInput(buffer, partial_merkle_tree);
+    CPartialMerkleTree partial_merkle_tree;
+    DeserializeFromFuzzingInput(buffer, partial_merkle_tree);
 })
 FUZZ_TARGET_DESERIALIZE(pub_key_deserialize, {
-        CPubKey pub_key;
-        DeserializeFromFuzzingInput(buffer, pub_key);
-        AssertEqualAfterSerializeDeserialize(pub_key);
+    CPubKey pub_key;
+    DeserializeFromFuzzingInput(buffer, pub_key);
+    AssertEqualAfterSerializeDeserialize(pub_key);
 })
 FUZZ_TARGET_DESERIALIZE(script_deserialize, {
-        CScript script;
-        DeserializeFromFuzzingInput(buffer, script);
-})
-FUZZ_TARGET_DESERIALIZE(subnet_deserialize, {
-        CSubNet sub_net_1;
-        DeserializeFromFuzzingInput(buffer, sub_net_1, INIT_PROTO_VERSION);
-        AssertEqualAfterSerializeDeserialize(sub_net_1, INIT_PROTO_VERSION);
-        CSubNet sub_net_2;
-        DeserializeFromFuzzingInput(buffer, sub_net_2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(sub_net_2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        CSubNet sub_net_3;
-        DeserializeFromFuzzingInput(buffer, sub_net_3);
-        AssertEqualAfterSerializeDeserialize(sub_net_3, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CScript script;
+    DeserializeFromFuzzingInput(buffer, script);
 })
 FUZZ_TARGET_DESERIALIZE(tx_in_deserialize, {
-        CTxIn tx_in;
-        DeserializeFromFuzzingInput(buffer, tx_in);
-        AssertEqualAfterSerializeDeserialize(tx_in);
+    CTxIn tx_in;
+    DeserializeFromFuzzingInput(buffer, tx_in);
+    AssertEqualAfterSerializeDeserialize(tx_in);
 })
 /*
 FUZZ_TARGET_DESERIALIZE(flat_file_pos_deserialize, {
-        FlatFilePos flat_file_pos;
-        DeserializeFromFuzzingInput(buffer, flat_file_pos);
-        AssertEqualAfterSerializeDeserialize(flat_file_pos);
+    FlatFilePos flat_file_pos;
+    DeserializeFromFuzzingInput(buffer, flat_file_pos);
+    AssertEqualAfterSerializeDeserialize(flat_file_pos);
 })
 FUZZ_TARGET_DESERIALIZE(key_origin_info_deserialize, {
-        KeyOriginInfo key_origin_info;
-        DeserializeFromFuzzingInput(buffer, key_origin_info);
-        AssertEqualAfterSerializeDeserialize(key_origin_info);
+    KeyOriginInfo key_origin_info;
+    DeserializeFromFuzzingInput(buffer, key_origin_info);
+    AssertEqualAfterSerializeDeserialize(key_origin_info);
 })
 */
 FUZZ_TARGET_DESERIALIZE(partially_signed_transaction_deserialize, {
-        PartiallySignedTransaction partially_signed_transaction;
-        DeserializeFromFuzzingInput(buffer, partially_signed_transaction);
+    PartiallySignedTransaction partially_signed_transaction;
+    DeserializeFromFuzzingInput(buffer, partially_signed_transaction);
 })
 FUZZ_TARGET_DESERIALIZE(prefilled_transaction_deserialize, {
-        PrefilledTransaction prefilled_transaction;
-        DeserializeFromFuzzingInput(buffer, prefilled_transaction);
+    PrefilledTransaction prefilled_transaction;
+    DeserializeFromFuzzingInput(buffer, prefilled_transaction);
 })
 FUZZ_TARGET_DESERIALIZE(psbt_input_deserialize, {
-        PSBTInput psbt_input;
-        DeserializeFromFuzzingInput(buffer, psbt_input);
+    PSBTInput psbt_input;
+    DeserializeFromFuzzingInput(buffer, psbt_input);
 })
 FUZZ_TARGET_DESERIALIZE(psbt_output_deserialize, {
-        PSBTOutput psbt_output;
-        DeserializeFromFuzzingInput(buffer, psbt_output);
+    PSBTOutput psbt_output;
+    DeserializeFromFuzzingInput(buffer, psbt_output);
 })
 FUZZ_TARGET_DESERIALIZE(block_deserialize, {
-        CBlock block;
-        DeserializeFromFuzzingInput(buffer, block);
+    CBlock block;
+    DeserializeFromFuzzingInput(buffer, block);
 })
 FUZZ_TARGET_DESERIALIZE(blocklocator_deserialize, {
-        CBlockLocator bl;
-        DeserializeFromFuzzingInput(buffer, bl);
+    CBlockLocator bl;
+    DeserializeFromFuzzingInput(buffer, bl);
 })
 FUZZ_TARGET_DESERIALIZE(blockmerkleroot, {
-        CBlock block;
-        DeserializeFromFuzzingInput(buffer, block);
-        bool mutated;
-        BlockMerkleRoot(block, &mutated);
+    CBlock block;
+    DeserializeFromFuzzingInput(buffer, block);
+    bool mutated;
+    BlockMerkleRoot(block, &mutated);
 })
 FUZZ_TARGET_DESERIALIZE(addrman_deserialize, {
-        CAddrMan am;
-        DeserializeFromFuzzingInput(buffer, am);
+    CAddrMan am;
+    DeserializeFromFuzzingInput(buffer, am);
 })
 FUZZ_TARGET_DESERIALIZE(blockheader_deserialize, {
-        CBlockHeader bh;
-        DeserializeFromFuzzingInput(buffer, bh);
+    CBlockHeader bh;
+    DeserializeFromFuzzingInput(buffer, bh);
 })
 FUZZ_TARGET_DESERIALIZE(banentry_deserialize, {
-        CBanEntry be;
-        DeserializeFromFuzzingInput(buffer, be);
+    CBanEntry be;
+    DeserializeFromFuzzingInput(buffer, be);
 })
 FUZZ_TARGET_DESERIALIZE(txundo_deserialize, {
-        CTxUndo tu;
-        DeserializeFromFuzzingInput(buffer, tu);
+    CTxUndo tu;
+    DeserializeFromFuzzingInput(buffer, tu);
 })
 FUZZ_TARGET_DESERIALIZE(blockundo_deserialize, {
-        CBlockUndo bu;
-        DeserializeFromFuzzingInput(buffer, bu);
+    CBlockUndo bu;
+    DeserializeFromFuzzingInput(buffer, bu);
 })
 FUZZ_TARGET_DESERIALIZE(coins_deserialize, {
-        Coin coin;
-        DeserializeFromFuzzingInput(buffer, coin);
+    Coin coin;
+    DeserializeFromFuzzingInput(buffer, coin);
 })
 FUZZ_TARGET_DESERIALIZE(net_address_deserialize, {
-        CNetAddr na;
-        DeserializeFromFuzzingInput(buffer, na);
-        if (na.IsAddrV1Compatible()) {
-            AssertEqualAfterSerializeDeserialize(na);
-        }
-        AssertEqualAfterSerializeDeserialize(na, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CNetAddr na;
+    DeserializeFromFuzzingInput(buffer, na);
+    if (na.IsAddrV1Compatible()) {
+        AssertEqualAfterSerializeDeserialize(na);
+    }
+    AssertEqualAfterSerializeDeserialize(na, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
 FUZZ_TARGET_DESERIALIZE(net_service_deserialize, {
-        CService s;
-        DeserializeFromFuzzingInput(buffer, s);
-        if (s.IsAddrV1Compatible()) {
-            AssertEqualAfterSerializeDeserialize(s);
-        }
-        AssertEqualAfterSerializeDeserialize(s, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        CService s1;
-        DeserializeFromFuzzingInput(buffer, s1, INIT_PROTO_VERSION);
-        AssertEqualAfterSerializeDeserialize(s1, INIT_PROTO_VERSION);
-        assert(s1.IsAddrV1Compatible());
-        CService s2;
-        DeserializeFromFuzzingInput(buffer, s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CService s;
+    DeserializeFromFuzzingInput(buffer, s);
+    if (s.IsAddrV1Compatible()) {
+        AssertEqualAfterSerializeDeserialize(s);
+    }
+    AssertEqualAfterSerializeDeserialize(s, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CService s1;
+    DeserializeFromFuzzingInput(buffer, s1, INIT_PROTO_VERSION);
+    AssertEqualAfterSerializeDeserialize(s1, INIT_PROTO_VERSION);
+    assert(s1.IsAddrV1Compatible());
+    CService s2;
+    DeserializeFromFuzzingInput(buffer, s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
 FUZZ_TARGET_DESERIALIZE(messageheader_deserialize, {
-        CMessageHeader mh;
-        DeserializeFromFuzzingInput(buffer, mh);
-        (void)mh.IsCommandValid();
+    CMessageHeader mh;
+    DeserializeFromFuzzingInput(buffer, mh);
+    (void)mh.IsCommandValid();
 })
 FUZZ_TARGET_DESERIALIZE(address_deserialize_v1_notime, {
-        CAddress a;
-        DeserializeFromFuzzingInput(buffer, a, INIT_PROTO_VERSION);
-        // A CAddress without nTime (as is expected under INIT_PROTO_VERSION) will roundtrip
-        // in all 5 formats (with/without nTime, v1/v2, network/disk)
-        AssertEqualAfterSerializeDeserialize(a, INIT_PROTO_VERSION);
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
-        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+    CAddress a;
+    DeserializeFromFuzzingInput(buffer, a, INIT_PROTO_VERSION);
+    // A CAddress without nTime (as is expected under INIT_PROTO_VERSION) will roundtrip
+    // in all 5 formats (with/without nTime, v1/v2, network/disk)
+    AssertEqualAfterSerializeDeserialize(a, INIT_PROTO_VERSION);
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+    AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(address_deserialize_v1_withtime, {
-        CAddress a;
-        DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION);
-        // A CAddress in V1 mode will roundtrip in all 4 formats that have nTime.
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
-        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+    CAddress a;
+    DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION);
+    // A CAddress in V1 mode will roundtrip in all 4 formats that have nTime.
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+    AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(address_deserialize_v2, {
-        CAddress a;
-        DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        // A CAddress in V2 mode will roundtrip in both V2 formats, and also in the V1 formats
-        // with time if it's V1 compatible.
-        if (a.IsAddrV1Compatible()) {
-            AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
-            AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
-        }
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+    CAddress a;
+    DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    // A CAddress in V2 mode will roundtrip in both V2 formats, and also in the V1 formats
+    // with time if it's V1 compatible.
+    if (a.IsAddrV1Compatible()) {
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+    }
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(inv_deserialize, {
-        CInv i;
-        DeserializeFromFuzzingInput(buffer, i);
+    CInv i;
+    DeserializeFromFuzzingInput(buffer, i);
 })
 FUZZ_TARGET_DESERIALIZE(bloomfilter_deserialize, {
-        CBloomFilter bf;
-        DeserializeFromFuzzingInput(buffer, bf);
+    CBloomFilter bf;
+    DeserializeFromFuzzingInput(buffer, bf);
 })
 FUZZ_TARGET_DESERIALIZE(diskblockindex_deserialize, {
-        CDiskBlockIndex dbi;
-        DeserializeFromFuzzingInput(buffer, dbi);
+    CDiskBlockIndex dbi;
+    DeserializeFromFuzzingInput(buffer, dbi);
 })
 FUZZ_TARGET_DESERIALIZE(txoutcompressor_deserialize, {
-        CTxOut to;
-        auto toc = Using<TxOutCompression>(to);
-        DeserializeFromFuzzingInput(buffer, toc);
+    CTxOut to;
+    auto toc = Using<TxOutCompression>(to);
+    DeserializeFromFuzzingInput(buffer, toc);
 })
 FUZZ_TARGET_DESERIALIZE(blocktransactions_deserialize, {
-        BlockTransactions bt;
-        DeserializeFromFuzzingInput(buffer, bt);
+    BlockTransactions bt;
+    DeserializeFromFuzzingInput(buffer, bt);
 })
 FUZZ_TARGET_DESERIALIZE(blocktransactionsrequest_deserialize, {
-        BlockTransactionsRequest btr;
-        DeserializeFromFuzzingInput(buffer, btr);
+    BlockTransactionsRequest btr;
+    DeserializeFromFuzzingInput(buffer, btr);
 })
 FUZZ_TARGET_DESERIALIZE(snapshotmetadata_deserialize, {
     SnapshotMetadata snapshot_metadata;
     DeserializeFromFuzzingInput(buffer, snapshot_metadata);
 })
 FUZZ_TARGET_DESERIALIZE(uint160_deserialize, {
-        uint160 u160;
-        DeserializeFromFuzzingInput(buffer, u160);
-        AssertEqualAfterSerializeDeserialize(u160);
+    uint160 u160;
+    DeserializeFromFuzzingInput(buffer, u160);
+    AssertEqualAfterSerializeDeserialize(u160);
 })
 FUZZ_TARGET_DESERIALIZE(uint256_deserialize, {
-        uint256 u256;
-        DeserializeFromFuzzingInput(buffer, u256);
-        AssertEqualAfterSerializeDeserialize(u256);
-})
-        // Classes intentionally not covered in this file since their deserialization code is
-        // fuzzed elsewhere:
-        // * Deserialization of CTxOut is fuzzed in test/fuzz/tx_out.cpp
-        // * Deserialization of CMutableTransaction is fuzzed in src/test/fuzz/transaction.cpp
+    uint256 u256;
+    DeserializeFromFuzzingInput(buffer, u256);
+    AssertEqualAfterSerializeDeserialize(u256);
+})
+// Classes intentionally not covered in this file since their deserialization code is
+// fuzzed elsewhere:
+// * Deserialization of CTxOut is fuzzed in test/fuzz/tx_out.cpp
+// * Deserialization of CMutableTransaction is fuzzed in src/test/fuzz/transaction.cpp

From 117083f39e65771c82dc8344696ef2b264267fd6 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 1 Nov 2021 16:32:53 -0400
Subject: [PATCH 21/21] merge bitcoin#23413: Replace MakeSpan helper with Span
 deduction guide

---
 src/base58.cpp            |   2 +-
 src/compressor.h          |   8 +--
 src/net.cpp               |   4 +-
 src/netaddress.cpp        |  10 +--
 src/netaddress.h          |   2 +-
 src/psbt.h                |   2 +-
 src/pubkey.h              |   4 +-
 src/script/descriptor.cpp |   4 +-
 src/script/sign.h         |   2 +-
 src/span.h                |  24 ++++---
 src/test/crypto_tests.cpp |   4 +-
 src/test/key_io_tests.cpp |   2 +-
 src/test/net_tests.cpp    | 140 +++++++++++++++++++-------------------
 src/test/util_tests.cpp   |   6 +-
 src/wallet/rpcdump.cpp    |   2 +-
 src/wallet/rpcwallet.cpp  |   3 +-
 16 files changed, 109 insertions(+), 110 deletions(-)

diff --git a/src/base58.cpp b/src/base58.cpp
index b505d52583c4e..834e09f7fb79a 100644
--- a/src/base58.cpp
+++ b/src/base58.cpp
@@ -149,7 +149,7 @@ bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet, int
         return false;
     }
     // re-calculate the checksum, ensure it matches the included 4-byte checksum
-    uint256 hash = Hash(MakeSpan(vchRet).first(vchRet.size() - 4));
+    uint256 hash = Hash(Span{vchRet}.first(vchRet.size() - 4));
     if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {
         vchRet.clear();
         return false;
diff --git a/src/compressor.h b/src/compressor.h
index 40b2496f06e81..00b777a1116de 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -65,12 +65,12 @@ struct ScriptCompression
     void Ser(Stream &s, const CScript& script) {
         CompressedScript compr;
         if (CompressScript(script, compr)) {
-            s << MakeSpan(compr);
+            s << Span{compr};
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
-        s << MakeSpan(script);
+        s << Span{script};
     }
 
     template<typename Stream>
@@ -79,7 +79,7 @@ struct ScriptCompression
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             CompressedScript vch(GetSpecialScriptSize(nSize), 0x00);
-            s >> MakeSpan(vch);
+            s >> Span{vch};
             DecompressScript(script, nSize, vch);
             return;
         }
@@ -90,7 +90,7 @@ struct ScriptCompression
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> MakeSpan(script);
+            s >> Span{script};
         }
     }
 };
diff --git a/src/net.cpp b/src/net.cpp
index f29ea026484a8..a3f62a09a1b49 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -838,8 +838,8 @@ std::optional<CNetMessage> V1TransportDeserializer::GetMessage(int64_t time, uin
     if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0) {
         LogPrint(BCLog::NET, "CHECKSUM ERROR (%s, %u bytes), expected %s was %s, peer=%d\n",
                  SanitizeString(msg->m_command), msg->m_message_size,
-                 HexStr(Span<uint8_t>(hash.begin(), hash.begin()+CMessageHeader::CHECKSUM_SIZE)),
-                 HexStr(Span<uint8_t>(hdr.pchChecksum, hdr.pchChecksum+CMessageHeader::CHECKSUM_SIZE)),
+                 HexStr(Span{hash}.first(CMessageHeader::CHECKSUM_SIZE)),
+                 HexStr(hdr.pchChecksum),
                  m_node_id);
         out_err_raw_size = msg->m_raw_message_size;
         msg.reset();
diff --git a/src/netaddress.cpp b/src/netaddress.cpp
index f94631d08767d..ac6afed471a55 100644
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -197,7 +197,7 @@ static void Checksum(Span<const uint8_t> addr_pubkey, uint8_t (&checksum)[CHECKS
 
     SHA3_256 hasher;
 
-    hasher.Write(MakeSpan(prefix).first(prefix_len));
+    hasher.Write(Span{prefix}.first(prefix_len));
     hasher.Write(addr_pubkey);
     hasher.Write(VERSION);
 
@@ -304,7 +304,7 @@ CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
 
 CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr, const uint32_t scope)
 {
-    SetLegacyIPv6(Span<const uint8_t>(reinterpret_cast<const uint8_t*>(&ipv6Addr), sizeof(ipv6Addr)));
+    SetLegacyIPv6({reinterpret_cast<const uint8_t*>(&ipv6Addr), sizeof(ipv6Addr)});
     m_scope_id = scope;
 }
 
@@ -669,13 +669,13 @@ uint32_t CNetAddr::GetLinkedIPv4() const
         return ReadBE32(m_addr.data());
     } else if (IsRFC6052() || IsRFC6145()) {
         // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
-        return ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
+        return ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
     } else if (IsRFC3964()) {
         // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
-        return ReadBE32(MakeSpan(m_addr).subspan(2, ADDR_IPV4_SIZE).data());
+        return ReadBE32(Span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
     } else if (IsRFC4380()) {
         // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
-        return ~ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
+        return ~ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
     }
     assert(false);
 }
diff --git a/src/netaddress.h b/src/netaddress.h
index 87fbb39efe849..b8001a4dd7327 100644
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -426,7 +426,7 @@ class CNetAddr
 
         if (SetNetFromBIP155Network(bip155_net, address_size)) {
             m_addr.resize(address_size);
-            s >> MakeSpan(m_addr);
+            s >> Span{m_addr};
 
             if (m_net != NET_IPV6) {
                 return;
diff --git a/src/psbt.h b/src/psbt.h
index 0769b208ac0f2..7a70345841538 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -70,7 +70,7 @@ struct PSBTInput
         if (final_script_sig.empty()) {
             // Write any partial signatures
             for (auto sig_pair : partial_sigs) {
-                SerializeToVector(s, PSBT_IN_PARTIAL_SIG, MakeSpan(sig_pair.second.first));
+                SerializeToVector(s, PSBT_IN_PARTIAL_SIG, Span{sig_pair.second.first});
                 s << sig_pair.second.second;
             }
 
diff --git a/src/pubkey.h b/src/pubkey.h
index c2aa8517259f1..79d2a1c1ff0bc 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -155,13 +155,13 @@ class CPubKey
     //! Get the KeyID of this public key (hash of its serialization)
     CKeyID GetID() const
     {
-        return CKeyID(Hash160(MakeSpan(vch).first(size())));
+        return CKeyID(Hash160(Span{vch}.first(size())));
     }
 
     //! Get the 256-bit hash of this public key.
     uint256 GetHash() const
     {
-        return Hash(MakeSpan(vch).first(size()));
+        return Hash(Span{vch}.first(size()));
     }
 
     /*
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 2dc1fe810e46e..eff6e3442ef55 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -759,10 +759,10 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(uint32_t key_exp_index, const S
     }
     KeyPath path;
     DeriveType type = DeriveType::NO;
-    if (split.back() == MakeSpan("*").first(1)) {
+    if (split.back() == Span{"*"}.first(1)) {
         split.pop_back();
         type = DeriveType::UNHARDENED;
-    } else if (split.back() == MakeSpan("*'").first(2) || split.back() == MakeSpan("*h").first(2)) {
+    } else if (split.back() == Span{"*'"}.first(2) || split.back() == Span{"*h"}.first(2)) {
         split.pop_back();
         type = DeriveType::HARDENED;
     }
diff --git a/src/script/sign.h b/src/script/sign.h
index 8160ea08141da..61881215ea648 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -136,7 +136,7 @@ void SerializeHDKeypaths(Stream& s, const std::map<CPubKey, KeyOriginInfo>& hd_k
         if (!keypath_pair.first.IsValid()) {
             throw std::ios_base::failure("Invalid CPubKey being serialized");
         }
-        SerializeToVector(s, type, MakeSpan(keypath_pair.first));
+        SerializeToVector(s, type, Span{keypath_pair.first});
         WriteCompactSize(s, (keypath_pair.second.path.size() + 1) * sizeof(uint32_t));
         s << keypath_pair.second.fingerprint;
         for (const auto& path : keypath_pair.second.path) {
diff --git a/src/span.h b/src/span.h
index b4bf6325dc041..fafa5faa0322b 100644
--- a/src/span.h
+++ b/src/span.h
@@ -218,13 +218,15 @@ class Span
     template <typename O> friend class Span;
 };
 
-// MakeSpan helps constructing a Span of the right type automatically.
-/** MakeSpan for arrays: */
-template <typename A, int N> Span<A> constexpr MakeSpan(A (&a)[N]) { return Span<A>(a, N); }
-/** MakeSpan for temporaries / rvalue references, only supporting const output. */
-template <typename V> constexpr auto MakeSpan(V&& v SPAN_ATTR_LIFETIMEBOUND) -> typename std::enable_if<!std::is_lvalue_reference<V>::value, Span<const typename std::remove_pointer<decltype(v.data())>::type>>::type { return std::forward<V>(v); }
-/** MakeSpan for (lvalue) references, supporting mutable output. */
-template <typename V> constexpr auto MakeSpan(V& v SPAN_ATTR_LIFETIMEBOUND) -> Span<typename std::remove_pointer<decltype(v.data())>::type> { return v; }
+// Deduction guides for Span
+// For the pointer/size based and iterator based constructor:
+template <typename T, typename EndOrSize> Span(T*, EndOrSize) -> Span<T>;
+// For the array constructor:
+template <typename T, std::size_t N> Span(T (&)[N]) -> Span<T>;
+// For the temporaries/rvalue references constructor, only supporting const output.
+template <typename T> Span(T&&) -> Span<std::enable_if_t<!std::is_lvalue_reference_v<T>, const std::remove_pointer_t<decltype(std::declval<T&&>().data())>>>;
+// For (lvalue) references, supporting mutable output.
+template <typename T> Span(T&) -> Span<std::remove_pointer_t<decltype(std::declval<T&>().data())>>;
 
 /** Pop the last element off a span, and return a reference to that element. */
 template <typename T>
@@ -257,12 +259,12 @@ Span<std::byte> AsWritableBytes(Span<T> s) noexcept
 template <typename V>
 Span<const std::byte> MakeByteSpan(V&& v) noexcept
 {
-    return AsBytes(MakeSpan(std::forward<V>(v)));
+    return AsBytes(Span{std::forward<V>(v)});
 }
 template <typename V>
 Span<std::byte> MakeWritableByteSpan(V&& v) noexcept
 {
-    return AsWritableBytes(MakeSpan(std::forward<V>(v)));
+    return AsWritableBytes(Span{std::forward<V>(v)});
 }
 
 // Helper functions to safely cast to unsigned char pointers.
@@ -275,7 +277,7 @@ inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_c
 // Helper function to safely convert a Span to a Span<[const] unsigned char>.
 template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
 
-/** Like MakeSpan, but for (const) unsigned char member types only. Only works for (un)signed char containers. */
-template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(MakeSpan(std::forward<V>(v)))) { return UCharSpanCast(MakeSpan(std::forward<V>(v))); }
+/** Like the Span constructor, but for (const) unsigned char member types only. Only works for (un)signed char containers. */
+template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
 
 #endif
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
index 6704c0fd32464..5522df311b2ca 100644
--- a/src/test/crypto_tests.cpp
+++ b/src/test/crypto_tests.cpp
@@ -794,8 +794,8 @@ static void TestSHA3_256(const std::string& input, const std::string& output)
     int s1 = InsecureRandRange(in_bytes.size() + 1);
     int s2 = InsecureRandRange(in_bytes.size() + 1 - s1);
     int s3 = in_bytes.size() - s1 - s2;
-    sha.Write(MakeSpan(in_bytes).first(s1)).Write(MakeSpan(in_bytes).subspan(s1, s2));
-    sha.Write(MakeSpan(in_bytes).last(s3)).Finalize(out);
+    sha.Write(Span{in_bytes}.first(s1)).Write(Span{in_bytes}.subspan(s1, s2));
+    sha.Write(Span{in_bytes}.last(s3)).Finalize(out);
     BOOST_CHECK(std::equal(std::begin(out_bytes), std::end(out_bytes), out));
 }
 
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index 5d0ef030a3b63..a495e8dc11d1e 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -47,7 +47,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
             privkey = DecodeSecret(exp_base58string);
             BOOST_CHECK_MESSAGE(privkey.IsValid(), "!IsValid:" + strTest);
             BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed, "compressed mismatch:" + strTest);
-            BOOST_CHECK_MESSAGE(Span<const uint8_t>{privkey} == Span<const uint8_t>{exp_payload}, "key mismatch:" + strTest);
+            BOOST_CHECK_MESSAGE(Span{privkey} == Span{exp_payload}, "key mismatch:" + strTest);
 
             // Private key must be invalid public key
             destination = DecodeDestination(exp_base58string);
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 4933f948fd0c1..579fe1dbec084 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -431,9 +431,9 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     s.SetVersion(s.GetVersion() | ADDRV2_FORMAT);
 
     // Valid IPv4.
-    s << MakeSpan(ParseHex("01"          // network type (IPv4)
-                           "04"          // address length
-                           "01020304")); // address
+    s << Span{ParseHex("01"          // network type (IPv4)
+                       "04"          // address length
+                       "01020304")}; // address
     s >> addr;
     BOOST_CHECK(addr.IsValid());
     BOOST_CHECK(addr.IsIPv4());
@@ -442,35 +442,35 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_REQUIRE(s.empty());
 
     // Invalid IPv4, valid length but address itself is shorter.
-    s << MakeSpan(ParseHex("01"      // network type (IPv4)
-                           "04"      // address length
-                           "0102")); // address
+    s << Span{ParseHex("01"      // network type (IPv4)
+                       "04"      // address length
+                       "0102")}; // address
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure, HasReason("end of data"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Invalid IPv4, with bogus length.
-    s << MakeSpan(ParseHex("01"          // network type (IPv4)
-                           "05"          // address length
-                           "01020304")); // address
+    s << Span{ParseHex("01"          // network type (IPv4)
+                       "05"          // address length
+                       "01020304")}; // address
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("BIP155 IPv4 address with length 5 (should be 4)"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Invalid IPv4, with extreme length.
-    s << MakeSpan(ParseHex("01"          // network type (IPv4)
-                           "fd0102"      // address length (513 as CompactSize)
-                           "01020304")); // address
+    s << Span{ParseHex("01"          // network type (IPv4)
+                       "fd0102"      // address length (513 as CompactSize)
+                       "01020304")}; // address
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("Address too long: 513 > 512"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Valid IPv6.
-    s << MakeSpan(ParseHex("02"                                  // network type (IPv6)
-                           "10"                                  // address length
-                           "0102030405060708090a0b0c0d0e0f10")); // address
+    s << Span{ParseHex("02"                                  // network type (IPv6)
+                       "10"                                  // address length
+                       "0102030405060708090a0b0c0d0e0f10")}; // address
     s >> addr;
     BOOST_CHECK(addr.IsValid());
     BOOST_CHECK(addr.IsIPv6());
@@ -479,10 +479,10 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_REQUIRE(s.empty());
 
     // Valid IPv6, contains embedded "internal".
-    s << MakeSpan(ParseHex(
+    s << Span{ParseHex(
         "02"                                  // network type (IPv6)
         "10"                                  // address length
-        "fd6b88c08724ca978112ca1bbdcafac2")); // address: 0xfd + sha256("bitcoin")[0:5] +
+        "fd6b88c08724ca978112ca1bbdcafac2")}; // address: 0xfd + sha256("bitcoin")[0:5] +
                                               // sha256(name)[0:10]
     s >> addr;
     BOOST_CHECK(addr.IsInternal());
@@ -491,44 +491,44 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_REQUIRE(s.empty());
 
     // Invalid IPv6, with bogus length.
-    s << MakeSpan(ParseHex("02"    // network type (IPv6)
-                           "04"    // address length
-                           "00")); // address
+    s << Span{ParseHex("02"    // network type (IPv6)
+                       "04"    // address length
+                       "00")}; // address
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("BIP155 IPv6 address with length 4 (should be 16)"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Invalid IPv6, contains embedded IPv4.
-    s << MakeSpan(ParseHex("02"                                  // network type (IPv6)
-                           "10"                                  // address length
-                           "00000000000000000000ffff01020304")); // address
+    s << Span{ParseHex("02"                                  // network type (IPv6)
+                       "10"                                  // address length
+                       "00000000000000000000ffff01020304")}; // address
     s >> addr;
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
     // Invalid IPv6, contains embedded TORv2.
-    s << MakeSpan(ParseHex("02"                                  // network type (IPv6)
-                           "10"                                  // address length
-                           "fd87d87eeb430102030405060708090a")); // address
+    s << Span{ParseHex("02"                                  // network type (IPv6)
+                       "10"                                  // address length
+                       "fd87d87eeb430102030405060708090a")}; // address
     s >> addr;
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
     // TORv2, no longer supported.
-    s << MakeSpan(ParseHex("03"                      // network type (TORv2)
-                           "0a"                      // address length
-                           "f1f2f3f4f5f6f7f8f9fa")); // address
+    s << Span{ParseHex("03"                      // network type (TORv2)
+                       "0a"                      // address length
+                       "f1f2f3f4f5f6f7f8f9fa")}; // address
     s >> addr;
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
     // Valid TORv3.
-    s << MakeSpan(ParseHex("04"                               // network type (TORv3)
-                           "20"                               // address length
-                           "79bcc625184b05194975c28b66b66b04" // address
-                           "69f7f6556fb1ac3189a79b40dda32f1f"
-                           ));
+    s << Span{ParseHex("04"                               // network type (TORv3)
+                       "20"                               // address length
+                       "79bcc625184b05194975c28b66b66b04" // address
+                       "69f7f6556fb1ac3189a79b40dda32f1f"
+                       )};
     s >> addr;
     BOOST_CHECK(addr.IsValid());
     BOOST_CHECK(addr.IsTor());
@@ -538,20 +538,20 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_REQUIRE(s.empty());
 
     // Invalid TORv3, with bogus length.
-    s << MakeSpan(ParseHex("04" // network type (TORv3)
-                           "00" // address length
-                           "00" // address
-                           ));
+    s << Span{ParseHex("04" // network type (TORv3)
+                       "00" // address length
+                       "00" // address
+                       )};
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("BIP155 TORv3 address with length 0 (should be 32)"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Valid I2P.
-    s << MakeSpan(ParseHex("05"                               // network type (I2P)
-                           "20"                               // address length
-                           "a2894dabaec08c0051a481a6dac88b64" // address
-                           "f98232ae42d4b6fd2fa81952dfe36a87"));
+    s << Span{ParseHex("05"                               // network type (I2P)
+                       "20"                               // address length
+                       "a2894dabaec08c0051a481a6dac88b64" // address
+                       "f98232ae42d4b6fd2fa81952dfe36a87")};
     s >> addr;
     BOOST_CHECK(addr.IsValid());
     BOOST_CHECK(addr.IsI2P());
@@ -561,20 +561,20 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_REQUIRE(s.empty());
 
     // Invalid I2P, with bogus length.
-    s << MakeSpan(ParseHex("05" // network type (I2P)
-                           "03" // address length
-                           "00" // address
-                           ));
+    s << Span{ParseHex("05" // network type (I2P)
+                       "03" // address length
+                       "00" // address
+                       )};
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("BIP155 I2P address with length 3 (should be 32)"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Valid CJDNS.
-    s << MakeSpan(ParseHex("06"                               // network type (CJDNS)
-                           "10"                               // address length
-                           "fc000001000200030004000500060007" // address
-                           ));
+    s << Span{ParseHex("06"                               // network type (CJDNS)
+                       "10"                               // address length
+                       "fc000001000200030004000500060007" // address
+                       )};
     s >> addr;
     BOOST_CHECK(addr.IsValid());
     BOOST_CHECK(addr.IsCJDNS());
@@ -583,49 +583,49 @@ BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
     BOOST_REQUIRE(s.empty());
 
     // Invalid CJDNS, wrong prefix.
-    s << MakeSpan(ParseHex("06"                               // network type (CJDNS)
-                           "10"                               // address length
-                           "aa000001000200030004000500060007" // address
-                           ));
+    s << Span{ParseHex("06"                               // network type (CJDNS)
+                       "10"                               // address length
+                       "aa000001000200030004000500060007" // address
+                       )};
     s >> addr;
     BOOST_CHECK(addr.IsCJDNS());
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
     // Invalid CJDNS, with bogus length.
-    s << MakeSpan(ParseHex("06" // network type (CJDNS)
-                           "01" // address length
-                           "00" // address
-                           ));
+    s << Span{ParseHex("06" // network type (CJDNS)
+                       "01" // address length
+                       "00" // address
+                       )};
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("BIP155 CJDNS address with length 1 (should be 16)"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Unknown, with extreme length.
-    s << MakeSpan(ParseHex("aa"             // network type (unknown)
-                           "fe00000002"     // address length (CompactSize's MAX_SIZE)
-                           "01020304050607" // address
-                           ));
+    s << Span{ParseHex("aa"             // network type (unknown)
+                       "fe00000002"     // address length (CompactSize's MAX_SIZE)
+                       "01020304050607" // address
+                       )};
     BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure,
                           HasReason("Address too long: 33554432 > 512"));
     BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
     s.clear();
 
     // Unknown, with reasonable length.
-    s << MakeSpan(ParseHex("aa"       // network type (unknown)
-                           "04"       // address length
-                           "01020304" // address
-                           ));
+    s << Span{ParseHex("aa"       // network type (unknown)
+                       "04"       // address length
+                       "01020304" // address
+                       )};
     s >> addr;
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
 
     // Unknown, with zero length.
-    s << MakeSpan(ParseHex("aa" // network type (unknown)
-                           "00" // address length
-                           ""   // address
-                           ));
+    s << Span{ParseHex("aa" // network type (unknown)
+                       "00" // address length
+                       ""   // address
+                       )};
     s >> addr;
     BOOST_CHECK(!addr.IsValid());
     BOOST_REQUIRE(s.empty());
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index b9a11454afabf..752366837e95e 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -177,13 +177,11 @@ BOOST_AUTO_TEST_CASE(util_HexStr)
         "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
 
     BOOST_CHECK_EQUAL(
-        HexStr(Span<const unsigned char>(
-               ParseHex_expected + sizeof(ParseHex_expected),
-               ParseHex_expected + sizeof(ParseHex_expected))),
+        HexStr(Span{ParseHex_expected}.last(0)),
         "");
 
     BOOST_CHECK_EQUAL(
-        HexStr(Span<const unsigned char>(ParseHex_expected, ParseHex_expected)),
+        HexStr(Span{ParseHex_expected}.first(0)),
         "");
 
     {
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 16246a25d6838..0ff6074e6317d 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -34,7 +34,7 @@ std::string static EncodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (const unsigned char c : str) {
         if (c <= 32 || c >= 128 || c == '%') {
-            ret << '%' << HexStr(Span<const unsigned char>(&c, 1));
+            ret << '%' << HexStr({&c, 1});
         } else {
             ret << c;
         }
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index a30824c37026a..16a33887b0611 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -4272,6 +4272,5 @@ static const CRPCCommand commands[] =
     { "wallet",             "wipewallettxes",                   &wipewallettxes,                {"keep_confirmed"} },
 };
 // clang-format on
-
-    return MakeSpan(commands);
+    return commands;
 }