diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 39f9d6d96..4e0f77186 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -1,359 +1,361 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_PRIMITIVES_TRANSACTION_H
 #define BITCOIN_PRIMITIVES_TRANSACTION_H
 
 #include <amount.h>
 #include <feerate.h>
 #include <primitives/txid.h>
 #include <script/script.h>
 #include <serialize.h>
 
 static const int SERIALIZE_TRANSACTION = 0x00;
 
 /**
  * An outpoint - a combination of a transaction hash and an index n into its
  * vout.
  */
 class COutPoint {
 private:
     TxId txid;
     uint32_t n;
 
 public:
-    COutPoint() : txid(), n(-1) {}
+    static constexpr uint32_t NULL_INDEX = std::numeric_limits<uint32_t>::max();
+
+    COutPoint() : txid(), n(NULL_INDEX) {}
     COutPoint(TxId txidIn, uint32_t nIn) : txid(txidIn), n(nIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(txid);
         READWRITE(n);
     }
 
-    bool IsNull() const { return txid.IsNull() && n == uint32_t(-1); }
+    bool IsNull() const { return txid.IsNull() && n == NULL_INDEX; }
 
     const TxId &GetTxId() const { return txid; }
     uint32_t GetN() const { return n; }
 
     friend bool operator<(const COutPoint &a, const COutPoint &b) {
         int cmp = a.txid.Compare(b.txid);
         return cmp < 0 || (cmp == 0 && a.n < b.n);
     }
 
     friend bool operator==(const COutPoint &a, const COutPoint &b) {
         return (a.txid == b.txid && a.n == b.n);
     }
 
     friend bool operator!=(const COutPoint &a, const COutPoint &b) {
         return !(a == b);
     }
 
     std::string ToString() const;
 };
 
 /**
  * An input of a transaction. It contains the location of the previous
  * transaction's output that it claims and a signature that matches the output's
  * public key.
  */
 class CTxIn {
 public:
     COutPoint prevout;
     CScript scriptSig;
     uint32_t nSequence;
 
     /**
      * Setting nSequence to this value for every input in a transaction disables
      * nLockTime.
      */
     static const uint32_t SEQUENCE_FINAL = 0xffffffff;
 
     /* Below flags apply in the context of BIP 68*/
     /**
      * If this flag set, CTxIn::nSequence is NOT interpreted as a relative
      * lock-time.
      */
     static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = (1U << 31);
 
     /**
      * If CTxIn::nSequence encodes a relative lock-time and this flag is set,
      * the relative lock-time has units of 512 seconds, otherwise it specifies
      * blocks with a granularity of 1.
      */
     static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22);
 
     /**
      * If CTxIn::nSequence encodes a relative lock-time, this mask is applied to
      * extract that lock-time from the sequence field.
      */
     static const uint32_t SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
 
     /**
      * In order to use the same number of bits to encode roughly the same
      * wall-clock duration, and because blocks are naturally limited to occur
      * every 600s on average, the minimum granularity for time-based relative
      * lock-time is fixed at 512 seconds. Converting from CTxIn::nSequence to
      * seconds is performed by multiplying by 512 = 2^9, or equivalently
      * shifting up by 9 bits.
      */
     static const int SEQUENCE_LOCKTIME_GRANULARITY = 9;
 
     CTxIn() { nSequence = SEQUENCE_FINAL; }
 
     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn = CScript(),
                    uint32_t nSequenceIn = SEQUENCE_FINAL)
         : prevout(prevoutIn), scriptSig(scriptSigIn), nSequence(nSequenceIn) {}
     CTxIn(TxId prevTxId, uint32_t nOut, CScript scriptSigIn = CScript(),
           uint32_t nSequenceIn = SEQUENCE_FINAL)
         : CTxIn(COutPoint(prevTxId, nOut), scriptSigIn, nSequenceIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(prevout);
         READWRITE(scriptSig);
         READWRITE(nSequence);
     }
 
     friend bool operator==(const CTxIn &a, const CTxIn &b) {
         return (a.prevout == b.prevout && a.scriptSig == b.scriptSig &&
                 a.nSequence == b.nSequence);
     }
 
     friend bool operator!=(const CTxIn &a, const CTxIn &b) { return !(a == b); }
 
     std::string ToString() const;
 };
 
 /**
  * An output of a transaction.  It contains the public key that the next input
  * must be able to sign with to claim it.
  */
 class CTxOut {
 public:
     Amount nValue;
     CScript scriptPubKey;
 
     CTxOut() { SetNull(); }
 
     CTxOut(Amount nValueIn, CScript scriptPubKeyIn)
         : nValue(nValueIn), scriptPubKey(scriptPubKeyIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(nValue);
         READWRITE(scriptPubKey);
     }
 
     void SetNull() {
         nValue = -SATOSHI;
         scriptPubKey.clear();
     }
 
     bool IsNull() const { return nValue == -SATOSHI; }
 
     friend bool operator==(const CTxOut &a, const CTxOut &b) {
         return (a.nValue == b.nValue && a.scriptPubKey == b.scriptPubKey);
     }
 
     friend bool operator!=(const CTxOut &a, const CTxOut &b) {
         return !(a == b);
     }
 
     std::string ToString() const;
 };
 
 class CMutableTransaction;
 
 /**
  * Basic transaction serialization format:
  * - int32_t nVersion
  * - std::vector<CTxIn> vin
  * - std::vector<CTxOut> vout
  * - uint32_t nLockTime
  */
 template <typename Stream, typename TxType>
 inline void UnserializeTransaction(TxType &tx, Stream &s) {
     s >> tx.nVersion;
     tx.vin.clear();
     tx.vout.clear();
     /* Try to read the vin. In case the dummy is there, this will be read as an
      * empty vector. */
     s >> tx.vin;
     /* We read a non-empty vin. Assume a normal vout follows. */
     s >> tx.vout;
     s >> tx.nLockTime;
 }
 
 template <typename Stream, typename TxType>
 inline void SerializeTransaction(const TxType &tx, Stream &s) {
     s << tx.nVersion;
     s << tx.vin;
     s << tx.vout;
     s << tx.nLockTime;
 }
 
 /**
  * The basic transaction that is broadcasted on the network and contained in
  * blocks. A transaction can contain multiple inputs and outputs.
  */
 class CTransaction {
 public:
     // Default transaction version.
     static const int32_t CURRENT_VERSION = 2;
 
     // Changing the default transaction version requires a two step process:
     // first adapting relay policy by bumping MAX_STANDARD_VERSION, and then
     // later date bumping the default CURRENT_VERSION at which point both
     // CURRENT_VERSION and MAX_STANDARD_VERSION will be equal.
     static const int32_t MAX_STANDARD_VERSION = 2;
 
     // The local variables are made const to prevent unintended modification
     // without updating the cached hash value. However, CTransaction is not
     // actually immutable; deserialization and assignment are implemented,
     // and bypass the constness. This is safe, as they update the entire
     // structure, including the hash.
     const std::vector<CTxIn> vin;
     const std::vector<CTxOut> vout;
     const int32_t nVersion;
     const uint32_t nLockTime;
 
 private:
     /** Memory only. */
     const uint256 hash;
 
     uint256 ComputeHash() const;
 
 public:
     /** Construct a CTransaction that qualifies as IsNull() */
     CTransaction();
 
     /** Convert a CMutableTransaction into a CTransaction. */
     explicit CTransaction(const CMutableTransaction &tx);
     explicit CTransaction(CMutableTransaction &&tx);
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         SerializeTransaction(*this, s);
     }
 
     /**
      * This deserializing constructor is provided instead of an Unserialize
      * method. Unserialize is not possible, since it would require overwriting
      * const fields.
      */
     template <typename Stream>
     CTransaction(deserialize_type, Stream &s)
         : CTransaction(CMutableTransaction(deserialize, s)) {}
 
     bool IsNull() const { return vin.empty() && vout.empty(); }
 
     const TxId GetId() const { return TxId(hash); }
     const TxHash GetHash() const { return TxHash(hash); }
 
     // Return sum of txouts.
     Amount GetValueOut() const;
     // GetValueIn() is a method on CCoinsViewCache, because
     // inputs must be known to compute value in.
 
     /**
      * Get the total transaction size in bytes.
      * @return Total transaction size in bytes
      */
     unsigned int GetTotalSize() const;
 
     bool IsCoinBase() const {
         return (vin.size() == 1 && vin[0].prevout.IsNull());
     }
 
     friend bool operator==(const CTransaction &a, const CTransaction &b) {
         return a.GetHash() == b.GetHash();
     }
 
     friend bool operator!=(const CTransaction &a, const CTransaction &b) {
         return !(a == b);
     }
 
     std::string ToString() const;
 };
 #if defined(__x86_64__)
 static_assert(sizeof(CTransaction) == 88,
               "sizeof CTransaction is expected to be 88 bytes");
 #endif
 
 /**
  * A mutable version of CTransaction.
  */
 class CMutableTransaction {
 public:
     std::vector<CTxIn> vin;
     std::vector<CTxOut> vout;
     int32_t nVersion;
     uint32_t nLockTime;
 
     CMutableTransaction();
     explicit CMutableTransaction(const CTransaction &tx);
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         SerializeTransaction(*this, s);
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         UnserializeTransaction(*this, s);
     }
 
     template <typename Stream>
     CMutableTransaction(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 
     /**
      * Compute the id and hash of this CMutableTransaction. This is computed on
      * the fly, as opposed to GetId() and GetHash() in CTransaction, which uses
      * a cached result.
      */
     TxId GetId() const;
     TxHash GetHash() const;
 
     friend bool operator==(const CMutableTransaction &a,
                            const CMutableTransaction &b) {
         return a.GetHash() == b.GetHash();
     }
 };
 #if defined(__x86_64__)
 static_assert(sizeof(CMutableTransaction) == 56,
               "sizeof CMutableTransaction is expected to be 56 bytes");
 #endif
 
 typedef std::shared_ptr<const CTransaction> CTransactionRef;
 static inline CTransactionRef MakeTransactionRef() {
     return std::make_shared<const CTransaction>();
 }
 template <typename Tx>
 static inline CTransactionRef MakeTransactionRef(Tx &&txIn) {
     return std::make_shared<const CTransaction>(std::forward<Tx>(txIn));
 }
 
 /** Precompute sighash midstate to avoid quadratic hashing */
 struct PrecomputedTransactionData {
     uint256 hashPrevouts, hashSequence, hashOutputs;
 
     PrecomputedTransactionData()
         : hashPrevouts(), hashSequence(), hashOutputs() {}
 
     PrecomputedTransactionData(const PrecomputedTransactionData &txdata)
         : hashPrevouts(txdata.hashPrevouts), hashSequence(txdata.hashSequence),
           hashOutputs(txdata.hashOutputs) {}
 
     template <class T> explicit PrecomputedTransactionData(const T &tx);
 };
 
 #endif // BITCOIN_PRIMITIVES_TRANSACTION_H
diff --git a/src/streams.h b/src/streams.h
index ed27bc909..839e44d9e 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -1,859 +1,860 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_STREAMS_H
 #define BITCOIN_STREAMS_H
 
 #include <serialize.h>
 #include <support/allocators/zeroafterfree.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <ios>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 template <typename Stream> class OverrideStream {
     Stream *stream;
 
     const int nType;
     const int nVersion;
 
 public:
     OverrideStream(Stream *stream_, int nType_, int nVersion_)
         : stream(stream_), nType(nType_), nVersion(nVersion_) {}
 
     template <typename T> OverrideStream<Stream> &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 
     template <typename T> OverrideStream<Stream> &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     void write(const char *pch, size_t nSize) { stream->write(pch, nSize); }
 
     void read(char *pch, size_t nSize) { stream->read(pch, nSize); }
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 };
 
 template <typename S> OverrideStream<S> WithOrVersion(S *s, int nVersionFlag) {
     return OverrideStream<S>(s, s->GetType(), s->GetVersion() | nVersionFlag);
 }
 
 /**
  * Minimal stream for overwriting and/or appending to an existing byte vector.
  *
  * The referenced vector will grow as necessary.
  */
 class CVectorWriter {
 public:
     /**
      * @param[in]  nTypeIn Serialization Type
      * @param[in]  nVersionIn Serialization Version (including any flags)
      * @param[in]  vchDataIn  Referenced byte vector to overwrite/append
      * @param[in]  nPosIn Starting position. Vector index where writes should
      * start. The vector will initially grow as necessary to  max(nPosIn,
      * vec.size()). So to append, use vec.size().
      */
     CVectorWriter(int nTypeIn, int nVersionIn, std::vector<uint8_t> &vchDataIn,
                   size_t nPosIn)
         : nType(nTypeIn), nVersion(nVersionIn), vchData(vchDataIn),
           nPos(nPosIn) {
         if (nPos > vchData.size()) {
             vchData.resize(nPos);
         }
     }
     /**
      * (other params same as above)
      * @param[in]  args  A list of items to serialize starting at nPosIn.
      */
     template <typename... Args>
     CVectorWriter(int nTypeIn, int nVersionIn, std::vector<uint8_t> &vchDataIn,
                   size_t nPosIn, Args &&... args)
         : CVectorWriter(nTypeIn, nVersionIn, vchDataIn, nPosIn) {
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
     void write(const char *pch, size_t nSize) {
         assert(nPos <= vchData.size());
         size_t nOverwrite = std::min(nSize, vchData.size() - nPos);
         if (nOverwrite) {
             memcpy(vchData.data() + nPos,
                    reinterpret_cast<const uint8_t *>(pch), nOverwrite);
         }
         if (nOverwrite < nSize) {
             vchData.insert(vchData.end(),
                            reinterpret_cast<const uint8_t *>(pch) + nOverwrite,
                            reinterpret_cast<const uint8_t *>(pch) + nSize);
         }
         nPos += nSize;
     }
     template <typename T> CVectorWriter &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
     void seek(size_t nSize) {
         nPos += nSize;
         if (nPos > vchData.size()) {
             vchData.resize(nPos);
         }
     }
 
 private:
     const int nType;
     const int nVersion;
     std::vector<uint8_t> &vchData;
     size_t nPos;
 };
 
 /**
  * Minimal stream for reading from an existing vector by reference
  */
 class VectorReader {
 private:
     const int m_type;
     const int m_version;
     const std::vector<uint8_t> &m_data;
     size_t m_pos = 0;
 
 public:
     /**
      * @param[in]  type Serialization Type
      * @param[in]  version Serialization Version (including any flags)
      * @param[in]  data Referenced byte vector to overwrite/append
      * @param[in]  pos Starting position. Vector index where reads should start.
      */
     VectorReader(int type, int version, const std::vector<uint8_t> &data,
                  size_t pos)
         : m_type(type), m_version(version), m_data(data), m_pos(pos) {
         if (m_pos > m_data.size()) {
             throw std::ios_base::failure(
                 "VectorReader(...): end of data (m_pos > m_data.size())");
         }
     }
 
     /**
      * (other params same as above)
      * @param[in]  args  A list of items to deserialize starting at pos.
      */
     template <typename... Args>
     VectorReader(int type, int version, const std::vector<uint8_t> &data,
                  size_t pos, Args &&... args)
         : VectorReader(type, version, data, pos) {
         ::UnserializeMany(*this, std::forward<Args>(args)...);
     }
 
     template <typename T> VectorReader &operator>>(T &obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     int GetVersion() const { return m_version; }
     int GetType() const { return m_type; }
 
     size_t size() const { return m_data.size() - m_pos; }
     bool empty() const { return m_data.size() == m_pos; }
 
     void read(char *dst, size_t n) {
         if (n == 0) {
             return;
         }
 
         // Read from the beginning of the buffer
         size_t pos_next = m_pos + n;
         if (pos_next > m_data.size()) {
             throw std::ios_base::failure("VectorReader::read(): end of data");
         }
         memcpy(dst, m_data.data() + m_pos, n);
         m_pos = pos_next;
     }
 };
 
 /**
  * Double ended buffer combining vector and stream-like interfaces.
  *
  * >> and << read and write unformatted data using the above serialization
  * templates. Fills with data in linear time; some stringstream implementations
  * take N^2 time.
  */
 class CDataStream {
 protected:
     typedef CSerializeData vector_type;
     vector_type vch;
     unsigned int nReadPos;
 
     int nType;
     int nVersion;
 
 public:
     typedef vector_type::allocator_type allocator_type;
     typedef vector_type::size_type size_type;
     typedef vector_type::difference_type difference_type;
     typedef vector_type::reference reference;
     typedef vector_type::const_reference const_reference;
     typedef vector_type::value_type value_type;
     typedef vector_type::iterator iterator;
     typedef vector_type::const_iterator const_iterator;
     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);
     }
 
     CDataStream(const std::vector<uint8_t> &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     template <typename... Args>
     CDataStream(int nTypeIn, int nVersionIn, Args &&... args) {
         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())); }
 
     //
     // Vector subset
     //
     const_iterator begin() const { return vch.begin() + nReadPos; }
     iterator begin() { return vch.begin() + nReadPos; }
     const_iterator end() const { return vch.end(); }
     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 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 char x = char()) {
         return vch.insert(it, x);
     }
     void insert(iterator it, size_type n, const char 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) {
         if (last == first) {
             return;
         }
 
         assert(last - first > 0);
         if (it == vch.begin() + nReadPos &&
             (unsigned int)(last - first) <= nReadPos) {
             // special case for inserting at the front when there's room
             nReadPos -= (last - first);
             memcpy(&vch[nReadPos], &first[0], last - first);
         } else {
             vch.insert(it, first, last);
         }
     }
 
     void insert(iterator it, const char *first, const char *last) {
         if (last == first) {
             return;
         }
 
         assert(last - first > 0);
         if (it == vch.begin() + nReadPos &&
             (unsigned int)(last - first) <= nReadPos) {
             // special case for inserting at the front when there's room
             nReadPos -= (last - first);
             memcpy(&vch[nReadPos], &first[0], last - first);
         } else {
             vch.insert(it, first, last);
         }
     }
 
     iterator erase(iterator it) {
         if (it == vch.begin() + nReadPos) {
             // special case for erasing from the front
             if (++nReadPos >= vch.size()) {
                 // whenever we reach the end, we take the opportunity to clear
                 // the buffer
                 nReadPos = 0;
                 return vch.erase(vch.begin(), vch.end());
             }
             return vch.begin() + nReadPos;
         } else {
             return vch.erase(it);
         }
     }
 
     iterator erase(iterator first, iterator last) {
         if (first == vch.begin() + nReadPos) {
             // special case for erasing from the front
             if (last == vch.end()) {
                 nReadPos = 0;
                 return vch.erase(vch.begin(), vch.end());
             } else {
                 nReadPos = (last - vch.begin());
                 return last;
             }
         } else
             return vch.erase(first, last);
     }
 
     inline void Compact() {
         vch.erase(vch.begin(), vch.begin() + nReadPos);
         nReadPos = 0;
     }
 
     bool Rewind(size_type n) {
         // Rewind by n characters if the buffer hasn't been compacted yet
         if (n > nReadPos) {
             return false;
         }
         nReadPos -= n;
         return true;
     }
 
     //
     // Stream subset
     //
     bool eof() const { return size() == 0; }
     CDataStream *rdbuf() { return this; }
     int in_avail() const { return size(); }
 
     void SetType(int n) { nType = n; }
     int GetType() const { return nType; }
     void SetVersion(int n) { nVersion = n; }
     int GetVersion() const { return nVersion; }
 
     void read(char *pch, size_t nSize) {
         if (nSize == 0) {
             return;
         }
 
         // Read from the beginning of the buffer
         unsigned int nReadPosNext = nReadPos + nSize;
         if (nReadPosNext > vch.size()) {
             throw std::ios_base::failure("CDataStream::read(): end of data");
         }
         memcpy(pch, &vch[nReadPos], nSize);
         if (nReadPosNext == vch.size()) {
             nReadPos = 0;
             vch.clear();
             return;
         }
         nReadPos = nReadPosNext;
     }
 
     void ignore(int nSize) {
         // Ignore from the beginning of the buffer
         if (nSize < 0) {
             throw std::ios_base::failure(
                 "CDataStream::ignore(): nSize negative");
         }
         unsigned int nReadPosNext = nReadPos + nSize;
         if (nReadPosNext >= vch.size()) {
             if (nReadPosNext > vch.size()) {
                 throw std::ios_base::failure(
                     "CDataStream::ignore(): end of data");
             }
             nReadPos = 0;
             vch.clear();
             return;
         }
         nReadPos = nReadPosNext;
     }
 
     void write(const char *pch, size_t nSize) {
         // Write to the end of the buffer
         vch.insert(vch.end(), pch, pch + nSize);
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         // Special case: stream << stream concatenates like stream += stream
         if (!vch.empty()) {
             s.write((char *)vch.data(), vch.size() * sizeof(value_type));
         }
     }
 
     template <typename T> CDataStream &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 
     template <typename T> CDataStream &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     void GetAndClear(CSerializeData &d) {
         d.insert(d.end(), begin(), end());
         clear();
     }
 
     /**
      * XOR the contents of this stream with a certain key.
      *
      * @param[in] key    The key used to XOR the data in this stream.
      */
     void Xor(const std::vector<uint8_t> &key) {
         if (key.size() == 0) {
             return;
         }
 
         for (size_type i = 0, j = 0; i != size(); i++) {
             vch[i] ^= key[j++];
 
             // This potentially acts on very many bytes of data, so it's
             // important that we calculate `j`, i.e. the `key` index in this way
             // instead of doing a %, which would effectively be a division for
             // each byte Xor'd -- much slower than need be.
             if (j == key.size()) j = 0;
         }
     }
 };
 
 template <typename IStream> class BitStreamReader {
 private:
     IStream &m_istream;
 
     /// Buffered byte read in from the input stream. A new byte is read into the
     /// buffer when m_offset reaches 8.
     uint8_t m_buffer{0};
 
     /// Number of high order bits in m_buffer already returned by previous
     /// Read() calls. The next bit to be returned is at this offset from the
     /// most significant bit position.
     int m_offset{8};
 
 public:
     explicit BitStreamReader(IStream &istream) : m_istream(istream) {}
 
     /**
      * Read the specified number of bits from the stream. The data is returned
      * in the nbits least significant bits of a 64-bit uint.
      */
     uint64_t Read(int nbits) {
         if (nbits < 0 || nbits > 64) {
             throw std::out_of_range("nbits must be between 0 and 64");
         }
 
         uint64_t data = 0;
         while (nbits > 0) {
             if (m_offset == 8) {
                 m_istream >> m_buffer;
                 m_offset = 0;
             }
 
             int bits = std::min(8 - m_offset, nbits);
             data <<= bits;
             data |= static_cast<uint8_t>(m_buffer << m_offset) >> (8 - bits);
             m_offset += bits;
             nbits -= bits;
         }
         return data;
     }
 };
 
 template <typename OStream> class BitStreamWriter {
 private:
     OStream &m_ostream;
 
     /// Buffered byte waiting to be written to the output stream. The byte is
     /// written buffer when m_offset reaches 8 or Flush() is called.
     uint8_t m_buffer{0};
 
     /// Number of high order bits in m_buffer already written by previous
     /// Write() calls and not yet flushed to the stream. The next bit to be
     /// written to is at this offset from the most significant bit position.
     int m_offset{0};
 
 public:
     explicit BitStreamWriter(OStream &ostream) : m_ostream(ostream) {}
 
     ~BitStreamWriter() { Flush(); }
 
     /**
      * Write the nbits least significant bits of a 64-bit int to the output
      * stream. Data is buffered until it completes an octet.
      */
     void Write(uint64_t data, int nbits) {
         if (nbits < 0 || nbits > 64) {
             throw std::out_of_range("nbits must be between 0 and 64");
         }
 
         while (nbits > 0) {
             int bits = std::min(8 - m_offset, nbits);
             m_buffer |= (data << (64 - nbits)) >> (64 - 8 + m_offset);
             m_offset += bits;
             nbits -= bits;
 
             if (m_offset == 8) {
                 Flush();
             }
         }
     }
 
     /**
      * Flush any unwritten bits to the output stream, padding with 0's to the
      * next byte boundary.
      */
     void Flush() {
         if (m_offset == 0) {
             return;
         }
 
         m_ostream << m_buffer;
         m_buffer = 0;
         m_offset = 0;
     }
 };
 
 /**
  * Non-refcounted RAII wrapper for FILE*
  *
  * Will automatically close the file when it goes out of scope if not null. If
  * you're returning the file pointer, return file.release(). If you need to
  * close the file early, use file.fclose() instead of fclose(file).
  */
 class CAutoFile {
 private:
     const int nType;
     const int nVersion;
 
     FILE *file;
 
 public:
     CAutoFile(FILE *filenew, int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn) {
         file = filenew;
     }
 
     ~CAutoFile() { fclose(); }
 
     // Disallow copies
     CAutoFile(const CAutoFile &) = delete;
     CAutoFile &operator=(const CAutoFile &) = delete;
 
     void fclose() {
         if (file) {
             ::fclose(file);
             file = nullptr;
         }
     }
 
     /**
      * Get wrapped FILE* with transfer of ownership.
      * @note This will invalidate the CAutoFile object, and makes it the
      * responsibility of the caller of this function to clean up the returned
      * FILE*.
      */
     FILE *release() {
         FILE *ret = file;
         file = nullptr;
         return ret;
     }
 
     /**
      * Get wrapped FILE* without transfer of ownership.
      * @note Ownership of the FILE* will remain with this class. Use this only
      * if the scope of the CAutoFile outlives use of the passed pointer.
      */
     FILE *Get() const { return file; }
 
     /** Return true if the wrapped FILE* is nullptr, false otherwise. */
     bool IsNull() const { return (file == nullptr); }
 
     //
     // Stream subset
     //
     int GetType() const { return nType; }
     int GetVersion() const { return nVersion; }
 
     void read(char *pch, size_t nSize) {
         if (!file) {
             throw std::ios_base::failure(
                 "CAutoFile::read: file handle is nullptr");
         }
         if (fread(pch, 1, nSize, file) != nSize) {
             throw std::ios_base::failure(feof(file)
                                              ? "CAutoFile::read: end of file"
                                              : "CAutoFile::read: fread failed");
         }
     }
 
     void ignore(size_t nSize) {
         if (!file) {
             throw std::ios_base::failure(
                 "CAutoFile::ignore: file handle is nullptr");
         }
         uint8_t data[4096];
         while (nSize > 0) {
             size_t nNow = std::min<size_t>(nSize, sizeof(data));
             if (fread(data, 1, nNow, file) != nNow) {
                 throw std::ios_base::failure(
                     feof(file) ? "CAutoFile::ignore: end of file"
                                : "CAutoFile::read: fread failed");
             }
             nSize -= nNow;
         }
     }
 
     void write(const char *pch, size_t nSize) {
         if (!file) {
             throw std::ios_base::failure(
                 "CAutoFile::write: file handle is nullptr");
         }
         if (fwrite(pch, 1, nSize, file) != nSize) {
             throw std::ios_base::failure("CAutoFile::write: write failed");
         }
     }
 
     template <typename T> CAutoFile &operator<<(const T &obj) {
         // Serialize to this stream
         if (!file) {
             throw std::ios_base::failure(
                 "CAutoFile::operator<<: file handle is nullptr");
         }
         ::Serialize(*this, obj);
         return (*this);
     }
 
     template <typename T> CAutoFile &operator>>(T &&obj) {
         // Unserialize from this stream
         if (!file) {
             throw std::ios_base::failure(
                 "CAutoFile::operator>>: file handle is nullptr");
         }
         ::Unserialize(*this, obj);
         return (*this);
     }
 };
 
 /**
  * Non-refcounted RAII wrapper around a FILE* that implements a ring buffer to
  * deserialize from. It guarantees the ability to rewind a given number of
  * bytes.
  *
  * Will automatically close the file when it goes out of scope if not null. If
  * you need to close the file early, use file.fclose() instead of fclose(file).
  */
 class CBufferedFile {
 private:
     const int nType;
     const int nVersion;
 
     // source file
     FILE *src;
     // how many bytes have been read from source
     uint64_t nSrcPos;
     // how many bytes have been read from this
     uint64_t nReadPos;
     // up to which position we're allowed to read
     uint64_t nReadLimit;
     // how many bytes we guarantee to rewind
     uint64_t nRewind;
     // the buffer
     std::vector<char> vchBuf;
 
 protected:
     // read data from the source to fill the buffer
     bool Fill() {
         unsigned int pos = nSrcPos % vchBuf.size();
         unsigned int readNow = vchBuf.size() - pos;
         unsigned int nAvail = vchBuf.size() - (nSrcPos - nReadPos) - nRewind;
         if (nAvail < readNow) {
             readNow = nAvail;
         }
         if (readNow == 0) {
             return false;
         }
         size_t nBytes = fread((void *)&vchBuf[pos], 1, readNow, src);
         if (nBytes == 0) {
             throw std::ios_base::failure(
                 feof(src) ? "CBufferedFile::Fill: end of file"
                           : "CBufferedFile::Fill: fread failed");
         } else {
             nSrcPos += nBytes;
             return true;
         }
     }
 
 public:
     CBufferedFile(FILE *fileIn, uint64_t nBufSize, uint64_t nRewindIn,
                   int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn), nSrcPos(0), nReadPos(0),
-          nReadLimit((uint64_t)(-1)), nRewind(nRewindIn), vchBuf(nBufSize, 0) {
+          nReadLimit(std::numeric_limits<uint64_t>::max()), nRewind(nRewindIn),
+          vchBuf(nBufSize, 0) {
         src = fileIn;
     }
 
     ~CBufferedFile() { fclose(); }
 
     // Disallow copies
     CBufferedFile(const CBufferedFile &) = delete;
     CBufferedFile &operator=(const CBufferedFile &) = delete;
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 
     void fclose() {
         if (src) {
             ::fclose(src);
             src = nullptr;
         }
     }
 
     // check whether we're at the end of the source file
     bool eof() const { return nReadPos == nSrcPos && feof(src); }
 
     // read a number of bytes
     void read(char *pch, size_t nSize) {
         if (nSize + nReadPos > nReadLimit) {
             throw std::ios_base::failure("Read attempted past buffer limit");
         }
         if (nSize + nRewind > vchBuf.size()) {
             throw std::ios_base::failure("Read larger than buffer size");
         }
         while (nSize > 0) {
             if (nReadPos == nSrcPos) {
                 Fill();
             }
             unsigned int pos = nReadPos % vchBuf.size();
             size_t nNow = nSize;
             if (nNow + pos > vchBuf.size()) {
                 nNow = vchBuf.size() - pos;
             }
             if (nNow + nReadPos > nSrcPos) {
                 nNow = nSrcPos - nReadPos;
             }
             memcpy(pch, &vchBuf[pos], nNow);
             nReadPos += nNow;
             pch += nNow;
             nSize -= nNow;
         }
     }
 
     // return the current reading position
     uint64_t GetPos() const { return nReadPos; }
 
     // rewind to a given reading position
     bool SetPos(uint64_t nPos) {
         nReadPos = nPos;
         if (nReadPos + nRewind < nSrcPos) {
             nReadPos = nSrcPos - nRewind;
             return false;
         } else if (nReadPos > nSrcPos) {
             nReadPos = nSrcPos;
             return false;
         } else {
             return true;
         }
     }
 
     bool Seek(uint64_t nPos) {
         long nLongPos = nPos;
         if (nPos != (uint64_t)nLongPos) {
             return false;
         }
         if (fseek(src, nLongPos, SEEK_SET)) {
             return false;
         }
         nLongPos = ftell(src);
         nSrcPos = nLongPos;
         nReadPos = nLongPos;
         return true;
     }
 
     // Prevent reading beyond a certain position. No argument removes the limit.
-    bool SetLimit(uint64_t nPos = (uint64_t)(-1)) {
+    bool SetLimit(uint64_t nPos = std::numeric_limits<uint64_t>::max()) {
         if (nPos < nReadPos) {
             return false;
         }
         nReadLimit = nPos;
         return true;
     }
 
     template <typename T> CBufferedFile &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     // search for a given byte in the stream, and remain positioned on it
     void FindByte(char ch) {
         while (true) {
             if (nReadPos == nSrcPos) {
                 Fill();
             }
             if (vchBuf[nReadPos % vchBuf.size()] == ch) {
                 break;
             }
             nReadPos++;
         }
     }
 };
 
 #endif // BITCOIN_STREAMS_H
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index 3cb6dec07..a509b774a 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -1,438 +1,438 @@
 // Copyright (c) 2012-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <serialize.h>
 
 #include <hash.h>
 #include <streams.h>
 #include <util/strencodings.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cstdint>
 #include <limits>
 
 BOOST_FIXTURE_TEST_SUITE(serialize_tests, BasicTestingSetup)
 
 class CSerializeMethodsTestSingle {
 protected:
     int intval;
     bool boolval;
     std::string stringval;
     char charstrval[16];
     CTransactionRef txval;
 
 public:
     CSerializeMethodsTestSingle() = default;
     CSerializeMethodsTestSingle(int intvalin, bool boolvalin,
                                 std::string stringvalin,
                                 const char *charstrvalin,
                                 const CTransactionRef &txvalin)
         : intval(intvalin), boolval(boolvalin),
           stringval(std::move(stringvalin)), txval(txvalin) {
         memcpy(charstrval, charstrvalin, sizeof(charstrval));
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(intval);
         READWRITE(boolval);
         READWRITE(stringval);
         READWRITE(charstrval);
         READWRITE(txval);
     }
 
     bool operator==(const CSerializeMethodsTestSingle &rhs) {
         return intval == rhs.intval && boolval == rhs.boolval &&
                stringval == rhs.stringval &&
                strcmp(charstrval, rhs.charstrval) == 0 && *txval == *rhs.txval;
     }
 };
 
 class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle {
 public:
     using CSerializeMethodsTestSingle::CSerializeMethodsTestSingle;
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(intval, boolval, stringval, charstrval, txval);
     }
 };
 
 BOOST_AUTO_TEST_CASE(sizes) {
     BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(char(0)));
     BOOST_CHECK_EQUAL(sizeof(int8_t), GetSerializeSize(int8_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(uint8_t(0)));
     BOOST_CHECK_EQUAL(sizeof(int16_t), GetSerializeSize(int16_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint16_t), GetSerializeSize(uint16_t(0)));
     BOOST_CHECK_EQUAL(sizeof(int32_t), GetSerializeSize(int32_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint32_t), GetSerializeSize(uint32_t(0)));
     BOOST_CHECK_EQUAL(sizeof(int64_t), GetSerializeSize(int64_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint64_t), GetSerializeSize(uint64_t(0)));
     BOOST_CHECK_EQUAL(sizeof(float), GetSerializeSize(float(0)));
     BOOST_CHECK_EQUAL(sizeof(double), GetSerializeSize(double(0)));
     // Bool is serialized as char
     BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(bool(0)));
 
     // Sanity-check GetSerializeSize and c++ type matching
     BOOST_CHECK_EQUAL(GetSerializeSize(char(0)), 1U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int8_t(0)), 1U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint8_t(0)), 1U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int16_t(0)), 2U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint16_t(0)), 2U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int32_t(0)), 4U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint32_t(0)), 4U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int64_t(0)), 8U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint64_t(0)), 8U);
     BOOST_CHECK_EQUAL(GetSerializeSize(float(0)), 4U);
     BOOST_CHECK_EQUAL(GetSerializeSize(double(0)), 8U);
     BOOST_CHECK_EQUAL(GetSerializeSize(bool(0)), 1U);
 }
 
 BOOST_AUTO_TEST_CASE(floats_conversion) {
     // Choose values that map unambiguously to binary floating point to avoid
     // rounding issues at the compiler side.
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x00000000), 0.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f000000), 0.5F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f800000), 1.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40000000), 2.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40800000), 4.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x44444444), 785.066650390625F);
 
     BOOST_CHECK_EQUAL(ser_float_to_uint32(0.0F), 0x00000000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(0.5F), 0x3f000000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(1.0F), 0x3f800000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(2.0F), 0x40000000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(4.0F), 0x40800000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(785.066650390625F), 0x44444444U);
 }
 
 BOOST_AUTO_TEST_CASE(doubles_conversion) {
     // Choose values that map unambiguously to binary floating point to avoid
     // rounding issues at the compiler side.
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x0000000000000000ULL), 0.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3fe0000000000000ULL), 0.5);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3ff0000000000000ULL), 1.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4000000000000000ULL), 2.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4010000000000000ULL), 4.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4088888880000000ULL),
                       785.066650390625);
 
     BOOST_CHECK_EQUAL(ser_double_to_uint64(0.0), 0x0000000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(0.5), 0x3fe0000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(1.0), 0x3ff0000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(2.0), 0x4000000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(4.0), 0x4010000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(785.066650390625),
                       0x4088888880000000ULL);
 }
 /*
 Python code to generate the below hashes:
 
     def reversed_hex(x):
         return binascii.hexlify(''.join(reversed(x)))
     def dsha256(x):
         return hashlib.sha256(hashlib.sha256(x).digest()).digest()
 
     reversed_hex(dsha256(''.join(struct.pack('<f', x) for x in range(0,1000))))
 == '8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c'
     reversed_hex(dsha256(''.join(struct.pack('<d', x) for x in range(0,1000))))
 == '43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96'
 */
 BOOST_AUTO_TEST_CASE(floats) {
     CDataStream ss(SER_DISK, 0);
     // encode
     for (int i = 0; i < 1000; i++) {
         ss << float(i);
     }
     BOOST_CHECK(Hash(ss.begin(), ss.end()) ==
                 uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85"
                          "099d7f3fe0c"));
 
     // decode
     for (int i = 0; i < 1000; i++) {
         float j;
         ss >> j;
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 }
 
 BOOST_AUTO_TEST_CASE(doubles) {
     CDataStream ss(SER_DISK, 0);
     // encode
     for (int i = 0; i < 1000; i++) {
         ss << double(i);
     }
     BOOST_CHECK(Hash(ss.begin(), ss.end()) ==
                 uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0"
                          "d7878b23f96"));
 
     // decode
     for (int i = 0; i < 1000; i++) {
         double j;
         ss >> j;
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 }
 
 BOOST_AUTO_TEST_CASE(varints) {
     // encode
 
     CDataStream ss(SER_DISK, 0);
     CDataStream::size_type size = 0;
     for (int i = 0; i < 100000; i++) {
         ss << VARINT(i, VarIntMode::NONNEGATIVE_SIGNED);
         size += ::GetSerializeSize(VARINT(i, VarIntMode::NONNEGATIVE_SIGNED));
         BOOST_CHECK(size == ss.size());
     }
 
     for (uint64_t i = 0; i < 100000000000ULL; i += 999999937) {
         ss << VARINT(i);
         size += ::GetSerializeSize(VARINT(i));
         BOOST_CHECK(size == ss.size());
     }
 
     // decode
     for (int i = 0; i < 100000; i++) {
         int j = -1;
         ss >> VARINT(j, VarIntMode::NONNEGATIVE_SIGNED);
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 
     for (uint64_t i = 0; i < 100000000000ULL; i += 999999937) {
-        uint64_t j = -1;
+        uint64_t j = std::numeric_limits<uint64_t>::max();
         ss >> VARINT(j);
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 }
 
 BOOST_AUTO_TEST_CASE(varints_bitpatterns) {
     CDataStream ss(SER_DISK, 0);
     ss << VARINT(0, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "00");
     ss.clear();
     ss << VARINT(0x7f, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "7f");
     ss.clear();
     ss << VARINT((int8_t)0x7f, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "7f");
     ss.clear();
     ss << VARINT(0x80, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "8000");
     ss.clear();
     ss << VARINT((uint8_t)0x80);
     BOOST_CHECK_EQUAL(HexStr(ss), "8000");
     ss.clear();
     ss << VARINT(0x1234, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "a334");
     ss.clear();
     ss << VARINT((int16_t)0x1234, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "a334");
     ss.clear();
     ss << VARINT(0xffff, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f");
     ss.clear();
     ss << VARINT((uint16_t)0xffff);
     BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f");
     ss.clear();
     ss << VARINT(0x123456, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "c7e756");
     ss.clear();
     ss << VARINT((int32_t)0x123456, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "c7e756");
     ss.clear();
     ss << VARINT(0x80123456U);
     BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756");
     ss.clear();
     ss << VARINT((uint32_t)0x80123456U);
     BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756");
     ss.clear();
     ss << VARINT(0xffffffff);
     BOOST_CHECK_EQUAL(HexStr(ss), "8efefefe7f");
     ss.clear();
     ss << VARINT(0x7fffffffffffffffLL, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "fefefefefefefefe7f");
     ss.clear();
     ss << VARINT(0xffffffffffffffffULL);
     BOOST_CHECK_EQUAL(HexStr(ss), "80fefefefefefefefe7f");
     ss.clear();
 }
 
 static bool isTooLargeException(const std::ios_base::failure &ex) {
     std::ios_base::failure expectedException(
         "ReadCompactSize(): size too large");
 
     // The string returned by what() can be different for different platforms.
     // Instead of directly comparing the ex.what() with an expected string,
     // create an instance of exception to see if ex.what() matches  the expected
     // explanatory string returned by the exception instance.
     return strcmp(expectedException.what(), ex.what()) == 0;
 }
 
 BOOST_AUTO_TEST_CASE(compactsize) {
     CDataStream ss(SER_DISK, 0);
     std::vector<char>::size_type i, j;
 
     for (i = 1; i <= MAX_SIZE; i *= 2) {
         WriteCompactSize(ss, i - 1);
         WriteCompactSize(ss, i);
     }
     for (i = 1; i <= MAX_SIZE; i *= 2) {
         j = ReadCompactSize(ss);
         BOOST_CHECK_MESSAGE((i - 1) == j,
                             "decoded:" << j << " expected:" << (i - 1));
         j = ReadCompactSize(ss);
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 
     WriteCompactSize(ss, MAX_SIZE);
     BOOST_CHECK_EQUAL(ReadCompactSize(ss), MAX_SIZE);
 
     WriteCompactSize(ss, MAX_SIZE + 1);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isTooLargeException);
 
     WriteCompactSize(ss, std::numeric_limits<int64_t>::max());
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isTooLargeException);
 
     WriteCompactSize(ss, std::numeric_limits<uint64_t>::max());
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isTooLargeException);
 }
 
 static bool isCanonicalException(const std::ios_base::failure &ex) {
     std::ios_base::failure expectedException("non-canonical ReadCompactSize()");
 
     // The string returned by what() can be different for different platforms.
     // Instead of directly comparing the ex.what() with an expected string,
     // create an instance of exception to see if ex.what() matches  the expected
     // explanatory string returned by the exception instance.
     return strcmp(expectedException.what(), ex.what()) == 0;
 }
 
 BOOST_AUTO_TEST_CASE(noncanonical) {
     // Write some non-canonical CompactSize encodings, and make sure an
     // exception is thrown when read back.
     CDataStream ss(SER_DISK, 0);
     std::vector<char>::size_type n;
 
     // zero encoded with three bytes:
     ss.write("\xfd\x00\x00", 3);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0xfc encoded with three bytes:
     ss.write("\xfd\xfc\x00", 3);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0xfd encoded with three bytes is OK:
     ss.write("\xfd\xfd\x00", 3);
     n = ReadCompactSize(ss);
     BOOST_CHECK(n == 0xfd);
 
     // zero encoded with five bytes:
     ss.write("\xfe\x00\x00\x00\x00", 5);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0xffff encoded with five bytes:
     ss.write("\xfe\xff\xff\x00\x00", 5);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // zero encoded with nine bytes:
     ss.write("\xff\x00\x00\x00\x00\x00\x00\x00\x00", 9);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0x01ffffff encoded with nine bytes:
     ss.write("\xff\xff\xff\xff\x01\x00\x00\x00\x00", 9);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 }
 
 BOOST_AUTO_TEST_CASE(insert_delete) {
     // Test inserting/deleting bytes.
     CDataStream ss(SER_DISK, 0);
     BOOST_CHECK_EQUAL(ss.size(), 0U);
 
     ss.write("\x00\x01\x02\xff", 4);
     BOOST_CHECK_EQUAL(ss.size(), 4U);
 
     char c = (char)11;
 
     // Inserting at beginning/end/middle:
     ss.insert(ss.begin(), c);
     BOOST_CHECK_EQUAL(ss.size(), 5U);
     BOOST_CHECK_EQUAL(ss[0], c);
     BOOST_CHECK_EQUAL(ss[1], 0);
 
     ss.insert(ss.end(), c);
     BOOST_CHECK_EQUAL(ss.size(), 6U);
     BOOST_CHECK_EQUAL(ss[4], (char)0xff);
     BOOST_CHECK_EQUAL(ss[5], c);
 
     ss.insert(ss.begin() + 2, c);
     BOOST_CHECK_EQUAL(ss.size(), 7U);
     BOOST_CHECK_EQUAL(ss[2], c);
 
     // Delete at beginning/end/middle
     ss.erase(ss.begin());
     BOOST_CHECK_EQUAL(ss.size(), 6U);
     BOOST_CHECK_EQUAL(ss[0], 0);
 
     ss.erase(ss.begin() + ss.size() - 1);
     BOOST_CHECK_EQUAL(ss.size(), 5U);
     BOOST_CHECK_EQUAL(ss[4], (char)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_AUTO_TEST_CASE(class_methods) {
     int intval(100);
     bool boolval(true);
     std::string stringval("testing");
     const char charstrval[16] = "testing charstr";
     CMutableTransaction txval;
     CTransactionRef tx_ref{MakeTransactionRef(txval)};
     CSerializeMethodsTestSingle methodtest1(intval, boolval, stringval,
                                             charstrval, tx_ref);
     CSerializeMethodsTestMany methodtest2(intval, boolval, stringval,
                                           charstrval, tx_ref);
     CSerializeMethodsTestSingle methodtest3;
     CSerializeMethodsTestMany methodtest4;
     CDataStream ss(SER_DISK, PROTOCOL_VERSION);
     BOOST_CHECK(methodtest1 == methodtest2);
     ss << methodtest1;
     ss >> methodtest4;
     ss << methodtest2;
     ss >> methodtest3;
     BOOST_CHECK(methodtest1 == methodtest2);
     BOOST_CHECK(methodtest2 == methodtest3);
     BOOST_CHECK(methodtest3 == methodtest4);
 
     CDataStream ss2(SER_DISK, PROTOCOL_VERSION, intval, boolval, stringval,
                     charstrval, txval);
     ss2 >> methodtest3;
     BOOST_CHECK(methodtest3 == methodtest4);
 }
 
 BOOST_AUTO_TEST_SUITE_END()