From 63b6b5226926eeca73700c581a8fc7ffe2d0ad11 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 19:09:55 -0700
Subject: [PATCH 01/26] Support deserializing into temporaries

Currently, the READWRITE macro cannot be passed any non-const temporaries, as
the SerReadWrite function only accepts lvalue references.

Deserializing into a temporary is very common, however. See for example
things like 's >> VARINT(n)'. The VARINT macro produces a temporary wrapper
that holds a reference to n.

Fix this by accepting non-const rvalue references instead of lvalue references.
We don't propagate the rvalue-ness down, as there are no useful optimizations
that only apply to temporaries.
---
 src/hash.h                      |  2 +-
 src/script/bitcoinconsensus.cpp |  2 +-
 src/serialize.h                 | 24 ++++++++++++------------
 src/streams.h                   |  8 ++++----
 4 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/hash.h b/src/hash.h
index b9952d39fc9..f9b3fa2ca18 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -187,7 +187,7 @@ class CHashVerifier : public CHashWriter
     }
 
     template<typename T>
-    CHashVerifier<Source>& operator>>(T& obj)
+    CHashVerifier<Source>& operator>>(T&& obj)
     {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
diff --git a/src/script/bitcoinconsensus.cpp b/src/script/bitcoinconsensus.cpp
index 03128917fd8..003ed5d0df0 100644
--- a/src/script/bitcoinconsensus.cpp
+++ b/src/script/bitcoinconsensus.cpp
@@ -40,7 +40,7 @@ class TxInputStream
     }
 
     template<typename T>
-    TxInputStream& operator>>(T& obj)
+    TxInputStream& operator>>(T&& obj)
     {
         ::Unserialize(*this, obj);
         return *this;
diff --git a/src/serialize.h b/src/serialize.h
index 8b86a07a767..8c7702e84e1 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -539,7 +539,7 @@ inline void Serialize(Stream& os, const T& a)
 }
 
 template<typename Stream, typename T>
-inline void Unserialize(Stream& is, T& a)
+inline void Unserialize(Stream& is, T&& a)
 {
     a.Unserialize(is);
 }
@@ -832,7 +832,7 @@ inline void SerReadWrite(Stream& s, const T& obj, CSerActionSerialize ser_action
 }
 
 template<typename Stream, typename T>
-inline void SerReadWrite(Stream& s, T& obj, CSerActionUnserialize ser_action)
+inline void SerReadWrite(Stream& s, T&& obj, CSerActionUnserialize ser_action)
 {
     ::Unserialize(s, obj);
 }
@@ -898,16 +898,16 @@ void SerializeMany(Stream& s)
 }
 
 template<typename Stream, typename Arg>
-void SerializeMany(Stream& s, Arg&& arg)
+void SerializeMany(Stream& s, const Arg& arg)
 {
-    ::Serialize(s, std::forward<Arg>(arg));
+    ::Serialize(s, arg);
 }
 
 template<typename Stream, typename Arg, typename... Args>
-void SerializeMany(Stream& s, Arg&& arg, Args&&... args)
+void SerializeMany(Stream& s, const Arg& arg, const Args&... args)
 {
-    ::Serialize(s, std::forward<Arg>(arg));
-    ::SerializeMany(s, std::forward<Args>(args)...);
+    ::Serialize(s, arg);
+    ::SerializeMany(s, args...);
 }
 
 template<typename Stream>
@@ -916,26 +916,26 @@ inline void UnserializeMany(Stream& s)
 }
 
 template<typename Stream, typename Arg>
-inline void UnserializeMany(Stream& s, Arg& arg)
+inline void UnserializeMany(Stream& s, Arg&& arg)
 {
     ::Unserialize(s, arg);
 }
 
 template<typename Stream, typename Arg, typename... Args>
-inline void UnserializeMany(Stream& s, Arg& arg, Args&... args)
+inline void UnserializeMany(Stream& s, Arg&& arg, Args&&... args)
 {
     ::Unserialize(s, arg);
     ::UnserializeMany(s, args...);
 }
 
 template<typename Stream, typename... Args>
-inline void SerReadWriteMany(Stream& s, CSerActionSerialize ser_action, Args&&... args)
+inline void SerReadWriteMany(Stream& s, CSerActionSerialize ser_action, const Args&... args)
 {
-    ::SerializeMany(s, std::forward<Args>(args)...);
+    ::SerializeMany(s, args...);
 }
 
 template<typename Stream, typename... Args>
-inline void SerReadWriteMany(Stream& s, CSerActionUnserialize ser_action, Args&... args)
+inline void SerReadWriteMany(Stream& s, CSerActionUnserialize ser_action, Args&&... args)
 {
     ::UnserializeMany(s, args...);
 }
diff --git a/src/streams.h b/src/streams.h
index a9668b68bcb..81267792e83 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -42,7 +42,7 @@ class OverrideStream
     }
 
     template<typename T>
-    OverrideStream<Stream>& operator>>(T& obj)
+    OverrideStream<Stream>& operator>>(T&& obj)
     {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
@@ -401,7 +401,7 @@ class CDataStream
     }
 
     template<typename T>
-    CDataStream& operator>>(T& obj)
+    CDataStream& operator>>(T&& obj)
     {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
@@ -545,7 +545,7 @@ class CAutoFile
     }
 
     template<typename T>
-    CAutoFile& operator>>(T& obj)
+    CAutoFile& operator>>(T&& obj)
     {
         // Unserialize from this stream
         if (!file)
@@ -688,7 +688,7 @@ class CBufferedFile
     }
 
     template<typename T>
-    CBufferedFile& operator>>(T& obj) {
+    CBufferedFile& operator>>(T&& obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);

From 6639b1865f2a1bc2b22b75c3135f076469d47bdf Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 15:48:13 -0700
Subject: [PATCH 02/26] Introduce new serialization macros without casts

This new approach uses a static method which takes the object as
a argument. This has the advantage that its constness can be a
template parameter, allowing a single implementation that sees the
object as const for serialization and non-const for deserialization,
without casts.

More boilerplate is included in the new macro as well.
---
 src/serialize.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/serialize.h b/src/serialize.h
index 8c7702e84e1..278f08492c5 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -167,6 +167,26 @@ enum
         SerializationOp(s, CSerActionUnserialize());                  \
     }
 
+/**
+ * Implement the Serialize and Unserialize methods by delegating to a single templated
+ * static method that takes the to-be-(de)serialized object as a parameter. This approach
+ * has the advantage that the constness of the object becomes a template parameter, and
+ * thus allows a single implementation that sees the object as const for serializing
+ * and non-const for deserializing, without casts.
+ */
+#define SERIALIZE_METHODS(obj)                                                      \
+    template<typename Stream>                                                       \
+    void Serialize(Stream& s) const {                                               \
+        SerializationOps(*this, s, CSerActionSerialize());                          \
+    }                                                                               \
+    template<typename Stream>                                                       \
+    void Unserialize(Stream& s) {                                                   \
+        SerializationOps(*this, s, CSerActionUnserialize());                        \
+    }                                                                               \
+    template<typename Stream, typename Type, typename Operation>                    \
+    static inline void SerializationOps(Type& obj, Stream& s, Operation ser_action) \
+
+
 template<typename Stream> inline void Serialize(Stream& s, char a    ) { ser_writedata8(s, a); } // TODO Get rid of bare char
 template<typename Stream> inline void Serialize(Stream& s, int8_t a  ) { ser_writedata8(s, a); }
 template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }

From 11811b7d12ed6ddb97ab6c2de372f648e506be85 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 16:06:56 -0700
Subject: [PATCH 03/26] Add READWRITEAS, a macro to serialize safely as a
 different type

---
 src/serialize.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/serialize.h b/src/serialize.h
index 278f08492c5..b7a9a831cdb 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -148,9 +148,21 @@ enum
     SER_GETHASH         = (1 << 2),
 };
 
+// Convert the reference base type to X, without changing constness or reference type.
+template<typename X> X& AsBaseType(X& x) { return x; }
+template<typename X> const X& AsBaseType(const X& x) { return x; }
+template<typename X> X&& AsBaseType(X&& x) { return std::move(x); }
+template<typename X> const X&& AsBaseType(const X&& x) { return std::move(x); }
+
 #define READWRITE(obj)      (::SerReadWrite(s, (obj), ser_action))
 #define READWRITEMANY(...)      (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
 
+/** Serialize/deserialize the given object after converting it to a reference of
+ *  type `typ`, while preserving reference type and constness. Use this instead
+ *  of casting manually, as it will not inadvertently remove constness.
+ */
+#define READWRITEAS(obj, typ) (::SerReadWrite(s, AsBaseType<typ>(obj), ser_action))
+
 /** 
  * Implement three methods for serializable objects. These are actually wrappers over
  * "SerializationOp" template, which implements the body of each class' serialization

From 2fd24cfa9f5a75fcf3611914bce080f23ebf64ae Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 13:11:38 -0700
Subject: [PATCH 04/26] Merge READWRITEMANY into READWRITE

READWRITEMANY is more general, and its single-argument form is
identical to READWRITE.

After this, only a variable-argument READWRITE remains.
---
 src/serialize.h              | 17 ++---------------
 src/test/serialize_tests.cpp |  2 +-
 2 files changed, 3 insertions(+), 16 deletions(-)

diff --git a/src/serialize.h b/src/serialize.h
index b7a9a831cdb..549b33b5b41 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -154,14 +154,13 @@ template<typename X> const X& AsBaseType(const X& x) { return x; }
 template<typename X> X&& AsBaseType(X&& x) { return std::move(x); }
 template<typename X> const X&& AsBaseType(const X&& x) { return std::move(x); }
 
-#define READWRITE(obj)      (::SerReadWrite(s, (obj), ser_action))
-#define READWRITEMANY(...)      (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
+#define READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
 
 /** Serialize/deserialize the given object after converting it to a reference of
  *  type `typ`, while preserving reference type and constness. Use this instead
  *  of casting manually, as it will not inadvertently remove constness.
  */
-#define READWRITEAS(obj, typ) (::SerReadWrite(s, AsBaseType<typ>(obj), ser_action))
+#define READWRITEAS(obj, typ) (::SerReadWriteMany(s, ser_action, AsBaseType<typ>(obj)))
 
 /** 
  * Implement three methods for serializable objects. These are actually wrappers over
@@ -857,18 +856,6 @@ struct CSerActionUnserialize
     constexpr bool ForRead() const { return true; }
 };
 
-template<typename Stream, typename T>
-inline void SerReadWrite(Stream& s, const T& obj, CSerActionSerialize ser_action)
-{
-    ::Serialize(s, obj);
-}
-
-template<typename Stream, typename T>
-inline void SerReadWrite(Stream& s, T&& obj, CSerActionUnserialize ser_action)
-{
-    ::Unserialize(s, obj);
-}
-
 
 
 
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index 9661a665140..36af6de88ea 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -53,7 +53,7 @@ class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITEMANY(intval, boolval, stringval, FLATDATA(charstrval), txval);
+        READWRITE(intval, boolval, stringval, FLATDATA(charstrval), txval);
     }
 };
 

From c38cfd6747d351c540ab71878c5640663921baaa Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 13:31:34 -0700
Subject: [PATCH 05/26] Add BigEndian serialization wrapper

---
 src/serialize.h | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/src/serialize.h b/src/serialize.h
index 549b33b5b41..c249fe8952a 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -72,6 +72,11 @@ template<typename Stream> inline void ser_writedata16(Stream &s, uint16_t obj)
     obj = htole16(obj);
     s.write((char*)&obj, 2);
 }
+template<typename Stream> inline void ser_writedata16be(Stream &s, uint16_t obj)
+{
+    obj = htobe16(obj);
+    s.write((char*)&obj, 2);
+}
 template<typename Stream> inline void ser_writedata32(Stream &s, uint32_t obj)
 {
     obj = htole32(obj);
@@ -94,6 +99,12 @@ template<typename Stream> inline uint16_t ser_readdata16(Stream &s)
     s.read((char*)&obj, 2);
     return le16toh(obj);
 }
+template<typename Stream> inline uint16_t ser_readdata16be(Stream &s)
+{
+    uint16_t obj;
+    s.read((char*)&obj, 2);
+    return be16toh(obj);
+}
 template<typename Stream> inline uint32_t ser_readdata32(Stream &s)
 {
     uint32_t obj;
@@ -493,9 +504,42 @@ class LimitedString
     }
 };
 
+/** Serialization wrapper class for big-endian integers.
+ *
+ * Use this wrapper around integer types that are stored in memory in native
+ * byte order, but serialized in big endian notation.
+ *
+ * Onlyy 16-bit types are supported for now.
+ */
+template<typename I, size_t S> class BigEndianWrapper
+{
+protected:
+    I& m_val;
+public:
+    BigEndianWrapper(I& val) : m_val(val)
+    {
+        static_assert(S == 2, "Unsupported BigEndian size");
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
+        if (S == 2) ser_writedata16be(s, m_val);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        if (S == 2) m_val = ser_readdata16be(s);
+    }
+};
+//! Automatically construct a BigEndianWrapper around the argument.
+template<typename I> static inline BigEndianWrapper<I,sizeof(I)> BigEndian(I& i) { return BigEndianWrapper<I,sizeof(I)>(i); }
+
 template<typename I>
 CVarInt<I> WrapVarInt(I& n) { return CVarInt<I>(n); }
 
+
 /**
  * Forward declarations
  */

From 3f71927fa06a7b1cbbd9c245adc78a7ab86abdfa Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 17:12:06 -0700
Subject: [PATCH 06/26] Generalize CompactSize wrapper

This makes it const-correct and usable for other integer types.
---
 src/serialize.h | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/serialize.h b/src/serialize.h
index c249fe8952a..d22fa870a96 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -395,7 +395,6 @@ I ReadVarInt(Stream& is)
 
 #define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
 #define VARINT(obj) REF(WrapVarInt(REF(obj)))
-#define COMPACTSIZE(obj) REF(CCompactSize(REF(obj)))
 #define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))
 
 /** 
@@ -457,23 +456,27 @@ class CVarInt
     }
 };
 
-class CCompactSize
+/** Serialization wrapper class for integers in CompactSize format. */
+template<typename I>
+class CompactSizeWrapper
 {
 protected:
-    uint64_t &n;
+    I &n;
 public:
-    CCompactSize(uint64_t& nIn) : n(nIn) { }
+    CompactSizeWrapper(I& nIn) : n(nIn) { }
 
     template<typename Stream>
-    void Serialize(Stream &s) const {
-        WriteCompactSize<Stream>(s, n);
+    void Unserialize(Stream& s) {
+        n = ReadCompactSize<Stream>(s);
     }
 
     template<typename Stream>
-    void Unserialize(Stream& s) {
-        n = ReadCompactSize<Stream>(s);
+    void Serialize(Stream& s) const {
+        WriteCompactSize<Stream>(s, n);
     }
 };
+//! Automatically construct a CompactSize wrapper around the argument.
+template<typename I> static inline CompactSizeWrapper<I> COMPACTSIZE(I& i) { return CompactSizeWrapper<I>(i); }
 
 template<size_t Limit>
 class LimitedString
@@ -539,7 +542,6 @@ template<typename I> static inline BigEndianWrapper<I,sizeof(I)> BigEndian(I& i)
 template<typename I>
 CVarInt<I> WrapVarInt(I& n) { return CVarInt<I>(n); }
 
-
 /**
  * Forward declarations
  */

From 7e7a055fccd8964c5373b907ae1a929377ac3c24 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 17:15:56 -0700
Subject: [PATCH 07/26] Generalize VarInt wrappers

---
 src/serialize.h | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/serialize.h b/src/serialize.h
index d22fa870a96..54785feac73 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -394,7 +394,6 @@ I ReadVarInt(Stream& is)
 }
 
 #define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
-#define VARINT(obj) REF(WrapVarInt(REF(obj)))
 #define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))
 
 /** 
@@ -437,17 +436,18 @@ class CFlatData
     }
 };
 
+/** Serialization wrapper class for integers in VarInt format. */
 template<typename I>
-class CVarInt
+class VarIntWrapper
 {
 protected:
     I &n;
 public:
-    CVarInt(I& nIn) : n(nIn) { }
+    VarIntWrapper(I& nIn) : n(nIn) { }
 
     template<typename Stream>
     void Serialize(Stream &s) const {
-        WriteVarInt<Stream,I>(s, n);
+        WriteVarInt(s, n);
     }
 
     template<typename Stream>
@@ -455,6 +455,8 @@ class CVarInt
         n = ReadVarInt<Stream,I>(s);
     }
 };
+//! Automatically construct a VarInt wrapper around the argument.
+template<typename I> static inline VarIntWrapper<typename std::remove_reference<I>::type> VARINT(I&& i) { return VarIntWrapper<typename std::remove_reference<I>::type>(i); }
 
 /** Serialization wrapper class for integers in CompactSize format. */
 template<typename I>
@@ -539,9 +541,6 @@ template<typename I, size_t S> class BigEndianWrapper
 //! Automatically construct a BigEndianWrapper around the argument.
 template<typename I> static inline BigEndianWrapper<I,sizeof(I)> BigEndian(I& i) { return BigEndianWrapper<I,sizeof(I)>(i); }
 
-template<typename I>
-CVarInt<I> WrapVarInt(I& n) { return CVarInt<I>(n); }
-
 /**
  * Forward declarations
  */

From 4b9d7b1954f3b90202522102161e9f3ca7e9d7e8 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 17:28:47 -0700
Subject: [PATCH 08/26] Generalize FlatData wrapper

---
 src/compressor.h |  8 ++++----
 src/serialize.h  | 40 ++++++++++++++++------------------------
 2 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/src/compressor.h b/src/compressor.h
index 015911484a1..95699850817 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -59,12 +59,12 @@ class CScriptCompressor
     void Serialize(Stream &s) const {
         std::vector<unsigned char> compr;
         if (Compress(compr)) {
-            s << CFlatData(compr);
+            s << FlatVector(compr);
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
-        s << CFlatData(script);
+        s << FlatVector(script);
     }
 
     template<typename Stream>
@@ -73,7 +73,7 @@ class CScriptCompressor
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             std::vector<unsigned char> vch(GetSpecialSize(nSize), 0x00);
-            s >> REF(CFlatData(vch));
+            s >> FlatVector(vch);
             Decompress(nSize, vch);
             return;
         }
@@ -84,7 +84,7 @@ class CScriptCompressor
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> REF(CFlatData(script));
+            s >> FlatVector(script);
         }
     }
 };
diff --git a/src/serialize.h b/src/serialize.h
index 54785feac73..4588c0b4ee9 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -393,35 +393,17 @@ I ReadVarInt(Stream& is)
     }
 }
 
-#define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
 #define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))
 
-/** 
- * Wrapper for serializing arrays and POD.
- */
-class CFlatData
+/** Wrapper for serializing arrays and POD. */
+template<typename C>
+class FlatRangeWrapper
 {
 protected:
-    char* pbegin;
-    char* pend;
+    C* pbegin;
+    C* pend;
 public:
-    CFlatData(void* pbeginIn, void* pendIn) : pbegin((char*)pbeginIn), pend((char*)pendIn) { }
-    template <class T, class TAl>
-    explicit CFlatData(std::vector<T,TAl> &v)
-    {
-        pbegin = (char*)v.data();
-        pend = (char*)(v.data() + v.size());
-    }
-    template <unsigned int N, typename T, typename S, typename D>
-    explicit CFlatData(prevector<N, T, S, D> &v)
-    {
-        pbegin = (char*)v.data();
-        pend = (char*)(v.data() + v.size());
-    }
-    char* begin() { return pbegin; }
-    const char* begin() const { return pbegin; }
-    char* end() { return pend; }
-    const char* end() const { return pend; }
+    FlatRangeWrapper(C* pbeginIn, C* pendIn) : pbegin(pbeginIn), pend(pendIn) { }
 
     template<typename Stream>
     void Serialize(Stream& s) const
@@ -435,6 +417,16 @@ class CFlatData
         s.read(pbegin, pend - pbegin);
     }
 };
+//! Construct a FlatRange wrapper around a const vector.
+template<typename T> static inline const FlatRangeWrapper<const char> FlatVector(const T& t) { return FlatRangeWrapper<const char>((const char*)t.data(), (const char*)(t.data() + t.size())); }
+//! Construct a FlatRange wrapper around a non-const vector.
+template<typename T> static inline FlatRangeWrapper<char> FlatVector(T& t) { return FlatRangeWrapper<char>((char*)t.data(), (char*)(t.data() + t.size())); }
+//! Construct a FlatRange wrapper around a const POD and array types.
+template<typename T> static inline const FlatRangeWrapper<const char> FlatDataInner(const T* t, size_t len) { return FlatRangeWrapper<const char>((const char*)t, ((const char*)t) + len); }
+//! Construct a FlatRange wrapper around a non-const POD and array types.
+template<typename T> static inline FlatRangeWrapper<char> FlatDataInner(T* t, size_t len) { return FlatRangeWrapper<char>((char*)t, ((char*)t) + len); }
+//! Helper macro to easily serialize POD types.
+#define FLATDATA(x) FlatDataInner(&(x), sizeof(x))
 
 /** Serialization wrapper class for integers in VarInt format. */
 template<typename I>

From 644e8c2c56588f2f83632fc1eff6b9583c7bade8 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 17:35:27 -0700
Subject: [PATCH 09/26] Generalize LimitedString wrapper

---
 src/serialize.h | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/serialize.h b/src/serialize.h
index 4588c0b4ee9..7786fd99e82 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -393,8 +393,6 @@ I ReadVarInt(Stream& is)
     }
 }
 
-#define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))
-
 /** Wrapper for serializing arrays and POD. */
 template<typename C>
 class FlatRangeWrapper
@@ -472,13 +470,14 @@ class CompactSizeWrapper
 //! Automatically construct a CompactSize wrapper around the argument.
 template<typename I> static inline CompactSizeWrapper<I> COMPACTSIZE(I& i) { return CompactSizeWrapper<I>(i); }
 
+/** Serialization wrapper class for strings of limited length. */
 template<size_t Limit>
-class LimitedString
+class LimitedStringWrapper
 {
 protected:
     std::string& string;
 public:
-    LimitedString(std::string& _string) : string(_string) {}
+    LimitedStringWrapper(std::string& _string) : string(_string) {}
 
     template<typename Stream>
     void Unserialize(Stream& s)
@@ -495,11 +494,14 @@ class LimitedString
     template<typename Stream>
     void Serialize(Stream& s) const
     {
-        WriteCompactSize(s, string.size());
-        if (!string.empty())
-            s.write((char*)string.data(), string.size());
+        s << string;
     }
 };
+//! Add a LimitedString wrapper around a const string (identity)
+template<size_t I> static inline const std::string& LimitedString(const std::string& str) { return str; }
+//! Add a LimitedString wrapper around a non-const string
+template<size_t I> static inline LimitedStringWrapper<I> LimitedString(std::string& str) { return LimitedStringWrapper<I>(str); }
+#define LIMITED_STRING(obj, n) LimitedString<n>(obj)
 
 /** Serialization wrapper class for big-endian integers.
  *
@@ -533,6 +535,7 @@ template<typename I, size_t S> class BigEndianWrapper
 //! Automatically construct a BigEndianWrapper around the argument.
 template<typename I> static inline BigEndianWrapper<I,sizeof(I)> BigEndian(I& i) { return BigEndianWrapper<I,sizeof(I)>(i); }
 
+
 /**
  * Forward declarations
  */

From 8db0bfe88496afa9c48502532d66b5edb1177327 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sun, 9 Jul 2017 22:45:24 -0700
Subject: [PATCH 10/26] Add custom vector-element serialization wrapper

This allows a very compact notation for serialization of vectors whose
elements are not serialized using their default encoding.
---
 src/serialize.h | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/src/serialize.h b/src/serialize.h
index 7786fd99e82..dcf1b5390ef 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -535,6 +535,64 @@ template<typename I, size_t S> class BigEndianWrapper
 //! Automatically construct a BigEndianWrapper around the argument.
 template<typename I> static inline BigEndianWrapper<I,sizeof(I)> BigEndian(I& i) { return BigEndianWrapper<I,sizeof(I)>(i); }
 
+/** Serialization wrapper for custom-element vectors.
+ *
+ * This allows (de)serialization of vectors of type V while using a custom
+ * serializer W for the entries inside.
+ *
+ * For const-correctness, the W parameter is a template itself.
+ * It is instantiated as W<const V::value_type> when serializing, and as
+ * W<V::value_type> when deserializing.
+ *
+ * Example:
+ *   struct X {
+ *     std::vector<uint64_t> v;
+ *     SERIALIZE_METHODS(obj) { READWRITE(VectorApply<VarIntWrapper>(obj.v)); }
+ *   };
+ * will define a struct that contains a vector of uint64_t, which is serialized
+ * as a vector of VarInt-encoded integers.
+ *
+ * V is not required to be an std::vector type. It works for any class that
+ * exposes a value_type, iteration, and resize method that behave like vectors.
+ */
+template<template <typename> class W, typename V> class VectorApplyWrapper
+{
+protected:
+    typedef typename V::value_type value_type;
+    V& m_vector;
+public:
+    VectorApplyWrapper(V& vector) : m_vector(vector) {}
+
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
+        WriteCompactSize(s, m_vector.size());
+        for (const value_type& x : m_vector) {
+            s << W<const value_type>(x);
+        }
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        m_vector.clear();
+        unsigned int nSize = ReadCompactSize(s);
+        unsigned int nMid = 0;
+        while (nMid < nSize) {
+            nMid += 5000000 / sizeof(value_type);
+            if (nMid > nSize) {
+                nMid = nSize;
+            }
+            m_vector.resize(nMid);
+            for (value_type& x : m_vector) {
+                s >> W<value_type>(x);
+            }
+        }
+    }
+};
+//! Automatically add a a VectorApply wrapper around the argument.
+template<template <typename> class W, typename V> static inline VectorApplyWrapper<W,V> VectorApply(V& vec) { return VectorApplyWrapper<W,V>(vec); }
+
 
 /**
  * Forward declarations

From a07a5bf86c6ae3b127db56eb6d56fa3c0b910cc4 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 15:49:26 -0700
Subject: [PATCH 11/26] Convert primitives to new serialization

---
 src/primitives/block.h       | 31 ++++++++++---------------------
 src/primitives/transaction.h | 25 +++----------------------
 2 files changed, 13 insertions(+), 43 deletions(-)

diff --git a/src/primitives/block.h b/src/primitives/block.h
index c90a1dfa644..3dcaa840538 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -33,16 +33,9 @@ class CBlockHeader
         SetNull();
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(this->nVersion);
-        READWRITE(hashPrevBlock);
-        READWRITE(hashMerkleRoot);
-        READWRITE(nTime);
-        READWRITE(nBits);
-        READWRITE(nNonce);
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce);
     }
 
     void SetNull()
@@ -89,12 +82,10 @@ class CBlock : public CBlockHeader
         *((CBlockHeader*)this) = header;
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(*(CBlockHeader*)this);
-        READWRITE(vtx);
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITEAS(obj, CBlockHeader);
+        READWRITE(obj.vtx);
     }
 
     void SetNull()
@@ -131,14 +122,12 @@ struct CBlockLocator
 
     CBlockLocator(const std::vector<uint256>& vHaveIn) : vHave(vHaveIn) {}
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    SERIALIZE_METHODS(obj)
+    {
         int nVersion = s.GetVersion();
         if (!(s.GetType() & SER_GETHASH))
             READWRITE(nVersion);
-        READWRITE(vHave);
+        READWRITE(obj.vHave);
     }
 
     void SetNull()
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 041034bb8b6..59f3ab05ee2 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -24,13 +24,7 @@ class COutPoint
     COutPoint(): n((uint32_t) -1) { }
     COutPoint(const uint256& hashIn, uint32_t nIn): hash(hashIn), n(nIn) { }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(hash);
-        READWRITE(n);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.hash, obj.n); }
 
     void SetNull() { hash.SetNull(); n = (uint32_t) -1; }
     bool IsNull() const { return (hash.IsNull() && n == (uint32_t) -1); }
@@ -101,14 +95,7 @@ class CTxIn
     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);
     CTxIn(uint256 hashPrevTx, uint32_t nOut, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(prevout);
-        READWRITE(scriptSig);
-        READWRITE(nSequence);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
 
     friend bool operator==(const CTxIn& a, const CTxIn& b)
     {
@@ -141,13 +128,7 @@ class CTxOut
 
     CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn);
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(nValue);
-        READWRITE(scriptPubKey);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
 
     void SetNull()
     {

From 3e233f8a065fc2623921d7b1c50562573fd4b72d Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 16:08:51 -0700
Subject: [PATCH 12/26] Convert addrdb/addrman to new serialization

---
 src/addrdb.h  | 10 +---------
 src/addrman.h | 12 ++++--------
 2 files changed, 5 insertions(+), 17 deletions(-)

diff --git a/src/addrdb.h b/src/addrdb.h
index 6cb36dfac4e..c47b30b5b9b 100644
--- a/src/addrdb.h
+++ b/src/addrdb.h
@@ -43,15 +43,7 @@ class CBanEntry
         nCreateTime = nCreateTimeIn;
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(this->nVersion);
-        READWRITE(nCreateTime);
-        READWRITE(nBanUntil);
-        READWRITE(banReason);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.nVersion, obj.nCreateTime, obj.nBanUntil, obj.banReason); }
 
     void SetNull()
     {
diff --git a/src/addrman.h b/src/addrman.h
index 547088aedf4..66c4c15ca40 100644
--- a/src/addrman.h
+++ b/src/addrman.h
@@ -55,14 +55,10 @@ class CAddrInfo : public CAddress
 
 public:
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(*(CAddress*)this);
-        READWRITE(source);
-        READWRITE(nLastSuccess);
-        READWRITE(nAttempts);
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITEAS(obj, CAddress);
+        READWRITE(obj.source, obj.nLastSuccess, obj.nAttempts);
     }
 
     void Init()

From 7be7fe531c490a0e11688c35f939034a84132d5e Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 19:06:57 -0700
Subject: [PATCH 13/26] Convert blockencodings to new serialization

---
 src/blockencodings.h              | 172 +++++++++++++++++---------------------
 src/test/blockencodings_tests.cpp |  19 +----
 2 files changed, 77 insertions(+), 114 deletions(-)

diff --git a/src/blockencodings.h b/src/blockencodings.h
index 5a1d80d4212..4a3a46be08e 100644
--- a/src/blockencodings.h
+++ b/src/blockencodings.h
@@ -12,58 +12,70 @@
 class CTxMemPool;
 
 // Dumb helper to handle CTransaction compression at serialize-time
-struct TransactionCompressor {
+template<typename T>
+struct TransactionCompressWrapper {
 private:
-    CTransactionRef& tx;
+    T& tx;
 public:
-    TransactionCompressor(CTransactionRef& txIn) : tx(txIn) {}
-
-    ADD_SERIALIZE_METHODS;
+    TransactionCompressWrapper(T& txIn) : tx(txIn) {}
+    SERIALIZE_METHODS(obj) { READWRITE(obj.tx); }
+};
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(tx); //TODO: Compress tx encoding
+template<typename I>
+struct Uint48Wrapper {
+private:
+    I& m_int;
+public:
+    Uint48Wrapper(I& i) : m_int(i) {}
+    template <typename Stream> void Serialize(Stream& s) const
+    {
+        uint32_t lsb = m_int & 0xffffffff;
+        uint16_t msb = (m_int >> 32) & 0xffff;
+        s << lsb << msb;
+    }
+    template <typename Stream> void Unserialize(Stream& s)
+    {
+        uint32_t lsb;
+        uint16_t msb;
+        s >> lsb >> msb;
+        m_int = (uint64_t(msb) << 32) | uint64_t(lsb);
     }
 };
 
+template<typename T>
+static inline TransactionCompressWrapper<T> TransactionCompressor(T& tx) { return TransactionCompressWrapper<T>(tx); }
+
 class BlockTransactionsRequest {
 public:
     // A BlockTransactionsRequest message
     uint256 blockhash;
     std::vector<uint16_t> indexes;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(blockhash);
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        s << blockhash;
         uint64_t indexes_size = (uint64_t)indexes.size();
-        READWRITE(COMPACTSIZE(indexes_size));
-        if (ser_action.ForRead()) {
-            size_t i = 0;
-            while (indexes.size() < indexes_size) {
-                indexes.resize(std::min((uint64_t)(1000 + indexes.size()), indexes_size));
-                for (; i < indexes.size(); i++) {
-                    uint64_t index = 0;
-                    READWRITE(COMPACTSIZE(index));
-                    if (index > std::numeric_limits<uint16_t>::max())
-                        throw std::ios_base::failure("index overflowed 16 bits");
-                    indexes[i] = index;
-                }
-            }
-
-            uint16_t offset = 0;
-            for (size_t j = 0; j < indexes.size(); j++) {
-                if (uint64_t(indexes[j]) + uint64_t(offset) > std::numeric_limits<uint16_t>::max())
-                    throw std::ios_base::failure("indexes overflowed 16 bits");
-                indexes[j] = indexes[j] + offset;
-                offset = indexes[j] + 1;
-            }
-        } else {
-            for (size_t i = 0; i < indexes.size(); i++) {
-                uint64_t index = indexes[i] - (i == 0 ? 0 : (indexes[i - 1] + 1));
-                READWRITE(COMPACTSIZE(index));
-            }
+        s << COMPACTSIZE(indexes_size);
+        for (size_t i = 0; i < indexes.size(); i++) {
+            const uint64_t index = indexes[i] - (i == 0 ? 0 : (indexes[i - 1] + 1));
+            s << COMPACTSIZE(index);
+        }
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        std::vector<uint64_t> tmp;
+        s >> blockhash >> VectorApply<CompactSizeWrapper>(tmp);
+
+        indexes.resize(tmp.size());
+        uint16_t offset = 0;
+        for (size_t j = 0; j < tmp.size(); j++) {
+            if (tmp[j] + uint64_t(offset) > std::numeric_limits<uint16_t>::max())
+                throw std::ios_base::failure("indexes overflowed 16 bits");
+            indexes[j] = tmp[j] + offset;
+            offset = indexes[j] + 1;
         }
     }
 };
@@ -78,24 +90,9 @@ class BlockTransactions {
     BlockTransactions(const BlockTransactionsRequest& req) :
         blockhash(req.blockhash), txn(req.indexes.size()) {}
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(blockhash);
-        uint64_t txn_size = (uint64_t)txn.size();
-        READWRITE(COMPACTSIZE(txn_size));
-        if (ser_action.ForRead()) {
-            size_t i = 0;
-            while (txn.size() < txn_size) {
-                txn.resize(std::min((uint64_t)(1000 + txn.size()), txn_size));
-                for (; i < txn.size(); i++)
-                    READWRITE(REF(TransactionCompressor(txn[i])));
-            }
-        } else {
-            for (size_t i = 0; i < txn.size(); i++)
-                READWRITE(REF(TransactionCompressor(txn[i])));
-        }
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(obj.blockhash, VectorApply<TransactionCompressWrapper>(obj.txn));
     }
 };
 
@@ -106,16 +103,21 @@ struct PrefilledTransaction {
     uint16_t index;
     CTransactionRef tx;
 
-    ADD_SERIALIZE_METHODS;
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
+        s << COMPACTSIZE(index) << TransactionCompressor(tx);
+    }
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        uint64_t idx = index;
-        READWRITE(COMPACTSIZE(idx));
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        uint64_t idx;
+        s >> COMPACTSIZE(idx);
         if (idx > std::numeric_limits<uint16_t>::max())
             throw std::ios_base::failure("index overflowed 16-bits");
         index = idx;
-        READWRITE(REF(TransactionCompressor(tx)));
+        s >> TransactionCompressor(tx);
     }
 };
 
@@ -154,40 +156,18 @@ class CBlockHeaderAndShortTxIDs {
 
     size_t BlockTxCount() const { return shorttxids.size() + prefilledtxn.size(); }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(header);
-        READWRITE(nonce);
-
-        uint64_t shorttxids_size = (uint64_t)shorttxids.size();
-        READWRITE(COMPACTSIZE(shorttxids_size));
-        if (ser_action.ForRead()) {
-            size_t i = 0;
-            while (shorttxids.size() < shorttxids_size) {
-                shorttxids.resize(std::min((uint64_t)(1000 + shorttxids.size()), shorttxids_size));
-                for (; i < shorttxids.size(); i++) {
-                    uint32_t lsb = 0; uint16_t msb = 0;
-                    READWRITE(lsb);
-                    READWRITE(msb);
-                    shorttxids[i] = (uint64_t(msb) << 32) | uint64_t(lsb);
-                    static_assert(SHORTTXIDS_LENGTH == 6, "shorttxids serialization assumes 6-byte shorttxids");
-                }
-            }
-        } else {
-            for (size_t i = 0; i < shorttxids.size(); i++) {
-                uint32_t lsb = shorttxids[i] & 0xffffffff;
-                uint16_t msb = (shorttxids[i] >> 32) & 0xffff;
-                READWRITE(lsb);
-                READWRITE(msb);
-            }
-        }
-
-        READWRITE(prefilledtxn);
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        s << header << nonce << VectorApply<Uint48Wrapper>(shorttxids) << prefilledtxn;
+    }
 
-        if (ser_action.ForRead())
-            FillShortTxIDSelector();
+    template <typename Stream>
+    inline void Unserialize(Stream& s)
+    {
+        static_assert(SHORTTXIDS_LENGTH == 6, "shorttxids serialization assumes 6-byte shorttxids");
+        s >> header >> nonce >> VectorApply<Uint48Wrapper>(shorttxids) >> prefilledtxn;
+        FillShortTxIDSelector();
     }
 };
 
diff --git a/src/test/blockencodings_tests.cpp b/src/test/blockencodings_tests.cpp
index 10a40fea3cb..f1168fa7a63 100644
--- a/src/test/blockencodings_tests.cpp
+++ b/src/test/blockencodings_tests.cpp
@@ -134,24 +134,7 @@ class TestHeaderAndShortIDs {
         return base.GetShortID(txhash);
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(header);
-        READWRITE(nonce);
-        size_t shorttxids_size = shorttxids.size();
-        READWRITE(VARINT(shorttxids_size));
-        shorttxids.resize(shorttxids_size);
-        for (size_t i = 0; i < shorttxids.size(); i++) {
-            uint32_t lsb = shorttxids[i] & 0xffffffff;
-            uint16_t msb = (shorttxids[i] >> 32) & 0xffff;
-            READWRITE(lsb);
-            READWRITE(msb);
-            shorttxids[i] = (uint64_t(msb) << 32) | uint64_t(lsb);
-        }
-        READWRITE(prefilledtxn);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.header, obj.nonce, VectorApply<Uint48Wrapper>(obj.shorttxids), obj.prefilledtxn); }
 };
 
 BOOST_AUTO_TEST_CASE(NonCoinbasePreforwardRTTest)

From f86296366d660c3e545d95d857c0f4247acab8c0 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 20:09:58 -0700
Subject: [PATCH 14/26] Convert merkleblock/bloom to new serialization

---
 src/bloom.h       | 10 +---------
 src/merkleblock.h | 48 +++++++++++++++++++++++-------------------------
 2 files changed, 24 insertions(+), 34 deletions(-)

diff --git a/src/bloom.h b/src/bloom.h
index 7ca96822396..c98458e263b 100644
--- a/src/bloom.h
+++ b/src/bloom.h
@@ -70,15 +70,7 @@ class CBloomFilter
     CBloomFilter(const unsigned int nElements, const double nFPRate, const unsigned int nTweak, unsigned char nFlagsIn);
     CBloomFilter() : isFull(true), isEmpty(false), nHashFuncs(0), nTweak(0), nFlags(0) {}
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(vData);
-        READWRITE(nHashFuncs);
-        READWRITE(nTweak);
-        READWRITE(nFlags);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.vData, obj.nHashFuncs, obj.nTweak, obj.nFlags); }
 
     void insert(const std::vector<unsigned char>& vKey);
     void insert(const COutPoint& outpoint);
diff --git a/src/merkleblock.h b/src/merkleblock.h
index f590c487dee..590419a0c64 100644
--- a/src/merkleblock.h
+++ b/src/merkleblock.h
@@ -81,27 +81,31 @@ class CPartialMerkleTree
 
 public:
 
-    /** serialization implementation */
-    ADD_SERIALIZE_METHODS;
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        s << nTransactions;
+        s << vHash;
+        std::vector<unsigned char> vBytes;
+        vBytes.resize((vBits.size()+7)/8);
+        for (unsigned int p = 0; p < vBits.size(); p++) {
+            vBytes[p / 8] |= vBits[p] << (p % 8);
+        }
+        s << vBytes;
+    }
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(nTransactions);
-        READWRITE(vHash);
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        s >> nTransactions;
+        s >> vHash;
         std::vector<unsigned char> vBytes;
-        if (ser_action.ForRead()) {
-            READWRITE(vBytes);
-            CPartialMerkleTree &us = *(const_cast<CPartialMerkleTree*>(this));
-            us.vBits.resize(vBytes.size() * 8);
-            for (unsigned int p = 0; p < us.vBits.size(); p++)
-                us.vBits[p] = (vBytes[p / 8] & (1 << (p % 8))) != 0;
-            us.fBad = false;
-        } else {
-            vBytes.resize((vBits.size()+7)/8);
-            for (unsigned int p = 0; p < vBits.size(); p++)
-                vBytes[p / 8] |= vBits[p] << (p % 8);
-            READWRITE(vBytes);
+        s >> vBytes;
+        vBits.resize(vBytes.size() * 8);
+        for (unsigned int p = 0; p < vBits.size(); p++) {
+            vBits[p] = (vBytes[p / 8] & (1 << (p % 8))) != 0;
         }
+        fBad = false;
     }
 
     /** Construct a partial merkle tree from a list of transaction ids, and a mask that selects a subset of them */
@@ -147,13 +151,7 @@ class CMerkleBlock
 
     CMerkleBlock() {}
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(header);
-        READWRITE(txn);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.header, obj.txn); }
 };
 
 #endif // BITCOIN_MERKLEBLOCK_H

From 8f3eec5acbae2da7f4ad2eabbb9fd5c1aa7d8163 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 20:27:39 -0700
Subject: [PATCH 15/26] Convert chain to new serialization

---
 src/chain.h | 64 ++++++++++++++++++++++++++-----------------------------------
 1 file changed, 27 insertions(+), 37 deletions(-)

diff --git a/src/chain.h b/src/chain.h
index 1223539e737..360df302e20 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -39,17 +39,15 @@ class CBlockFileInfo
     uint64_t nTimeFirst;       //!< earliest time of block in file
     uint64_t nTimeLast;        //!< latest time of block in file
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(VARINT(nBlocks));
-        READWRITE(VARINT(nSize));
-        READWRITE(VARINT(nUndoSize));
-        READWRITE(VARINT(nHeightFirst));
-        READWRITE(VARINT(nHeightLast));
-        READWRITE(VARINT(nTimeFirst));
-        READWRITE(VARINT(nTimeLast));
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(VARINT(obj.nBlocks));
+        READWRITE(VARINT(obj.nSize));
+        READWRITE(VARINT(obj.nUndoSize));
+        READWRITE(VARINT(obj.nHeightFirst));
+        READWRITE(VARINT(obj.nHeightLast));
+        READWRITE(VARINT(obj.nTimeFirst));
+        READWRITE(VARINT(obj.nTimeLast));
     }
 
      void SetNull() {
@@ -87,13 +85,7 @@ struct CDiskBlockPos
     int nFile;
     unsigned int nPos;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(VARINT(nFile));
-        READWRITE(VARINT(nPos));
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(VARINT(obj.nFile), VARINT(obj.nPos)); }
 
     CDiskBlockPos() {
         SetNull();
@@ -380,31 +372,29 @@ class CDiskBlockIndex : public CBlockIndex
         hashPrev = (pprev ? pprev->GetBlockHash() : uint256());
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    SERIALIZE_METHODS(obj)
+    {
         int _nVersion = s.GetVersion();
         if (!(s.GetType() & SER_GETHASH))
             READWRITE(VARINT(_nVersion));
 
-        READWRITE(VARINT(nHeight));
-        READWRITE(VARINT(nStatus));
-        READWRITE(VARINT(nTx));
-        if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
-            READWRITE(VARINT(nFile));
-        if (nStatus & BLOCK_HAVE_DATA)
-            READWRITE(VARINT(nDataPos));
-        if (nStatus & BLOCK_HAVE_UNDO)
-            READWRITE(VARINT(nUndoPos));
+        READWRITE(VARINT(obj.nHeight));
+        READWRITE(VARINT(obj.nStatus));
+        READWRITE(VARINT(obj.nTx));
+        if (obj.nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
+            READWRITE(VARINT(obj.nFile));
+        if (obj.nStatus & BLOCK_HAVE_DATA)
+            READWRITE(VARINT(obj.nDataPos));
+        if (obj.nStatus & BLOCK_HAVE_UNDO)
+            READWRITE(VARINT(obj.nUndoPos));
 
         // block header
-        READWRITE(this->nVersion);
-        READWRITE(hashPrev);
-        READWRITE(hashMerkleRoot);
-        READWRITE(nTime);
-        READWRITE(nBits);
-        READWRITE(nNonce);
+        READWRITE(obj.nVersion);
+        READWRITE(obj.hashPrev);
+        READWRITE(obj.hashMerkleRoot);
+        READWRITE(obj.nTime);
+        READWRITE(obj.nBits);
+        READWRITE(obj.nNonce);
     }
 
     uint256 GetBlockHash() const

From 43c46b303bfb90f3f6446827ec3af33f2433df94 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 14:02:42 -0700
Subject: [PATCH 16/26] Convert feerate to new serialization

---
 src/policy/feerate.h | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/policy/feerate.h b/src/policy/feerate.h
index 565da6c1541..3953cf47f67 100644
--- a/src/policy/feerate.h
+++ b/src/policy/feerate.h
@@ -44,12 +44,7 @@ class CFeeRate
     CFeeRate& operator+=(const CFeeRate& a) { nSatoshisPerK += a.nSatoshisPerK; return *this; }
     std::string ToString() const;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(nSatoshisPerK);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.nSatoshiPerK); }
 };
 
 #endif //  BITCOIN_POLICY_FEERATE_H

From b016fe3603a00514c2cb8703325dc6ab8514a016 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 14:12:47 -0700
Subject: [PATCH 17/26] Convert protocol to new serialization

---
 src/protocol.h | 34 +++++++---------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)

diff --git a/src/protocol.h b/src/protocol.h
index 7890bb627de..f7a1f87f3a9 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -45,15 +45,9 @@ class CMessageHeader
     std::string GetCommand() const;
     bool IsValid(const MessageStartChars& messageStart) const;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
+    SERIALIZE_METHODS(obj)
     {
-        READWRITE(FLATDATA(pchMessageStart));
-        READWRITE(FLATDATA(pchCommand));
-        READWRITE(nMessageSize);
-        READWRITE(FLATDATA(pchChecksum));
+        READWRITE(FLATDATA(obj.pchMessageStart), FLATDATA(obj.pchCommand), obj.nMessageSize, FLATDATA(obj.pchChecksum));
     }
 
     char pchMessageStart[MESSAGE_START_SIZE];
@@ -286,23 +280,16 @@ class CAddress : public CService
 
     void Init();
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
+    SERIALIZE_METHODS(obj)
     {
-        if (ser_action.ForRead())
-            Init();
         int nVersion = s.GetVersion();
         if (s.GetType() & SER_DISK)
             READWRITE(nVersion);
         if ((s.GetType() & SER_DISK) ||
             (nVersion >= CADDR_TIME_VERSION && !(s.GetType() & SER_GETHASH)))
-            READWRITE(nTime);
-        uint64_t nServicesInt = nServices;
-        READWRITE(nServicesInt);
-        nServices = (ServiceFlags)nServicesInt;
-        READWRITE(*(CService*)this);
+            READWRITE(obj.nTime);
+        READWRITEAS(obj.nServices, uint64_t);
+        READWRITEAS(obj, CService);
     }
 
     // TODO: make private (improves encapsulation)
@@ -341,14 +328,7 @@ class CInv
     CInv();
     CInv(int typeIn, const uint256& hashIn);
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
-        READWRITE(type);
-        READWRITE(hash);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.type, obj.hash); }
 
     friend bool operator<(const CInv& a, const CInv& b);
 

From 55461876f8bb1d37e409e2d273879909b0a3f6a5 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 16:43:34 -0700
Subject: [PATCH 18/26] Move compressor utility functions out of class

---
 src/compressor.cpp          | 30 +++++++++++++++++++-----------
 src/compressor.h            | 31 ++++++++++---------------------
 src/test/compress_tests.cpp |  8 ++++----
 3 files changed, 33 insertions(+), 36 deletions(-)

diff --git a/src/compressor.cpp b/src/compressor.cpp
index f4c12f38d2d..52624195495 100644
--- a/src/compressor.cpp
+++ b/src/compressor.cpp
@@ -9,7 +9,15 @@
 #include "pubkey.h"
 #include "script/standard.h"
 
-bool CScriptCompressor::IsToKeyID(CKeyID &hash) const
+/*
+ * These check for scripts for which a special case with a shorter encoding is defined.
+ * They are implemented separately from the CScript test, as these test for exact byte
+ * sequence correspondences, and are more strict. For example, IsToPubKey also verifies
+ * whether the public key is valid (as invalid ones cannot be represented in compressed
+ * form).
+ */
+
+static bool IsToKeyID(const CScript& script, CKeyID &hash)
 {
     if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160
                             && script[2] == 20 && script[23] == OP_EQUALVERIFY
@@ -20,7 +28,7 @@ bool CScriptCompressor::IsToKeyID(CKeyID &hash) const
     return false;
 }
 
-bool CScriptCompressor::IsToScriptID(CScriptID &hash) const
+static bool IsToScriptID(const CScript& script, CScriptID &hash)
 {
     if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20
                             && script[22] == OP_EQUAL) {
@@ -30,7 +38,7 @@ bool CScriptCompressor::IsToScriptID(CScriptID &hash) const
     return false;
 }
 
-bool CScriptCompressor::IsToPubKey(CPubKey &pubkey) const
+static bool IsToPubKey(const CScript& script, CPubKey &pubkey)
 {
     if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG
                             && (script[1] == 0x02 || script[1] == 0x03)) {
@@ -45,24 +53,24 @@ bool CScriptCompressor::IsToPubKey(CPubKey &pubkey) const
     return false;
 }
 
-bool CScriptCompressor::Compress(std::vector<unsigned char> &out) const
+bool CompressScript(const CScript& script, std::vector<unsigned char> &out)
 {
     CKeyID keyID;
-    if (IsToKeyID(keyID)) {
+    if (IsToKeyID(script, keyID)) {
         out.resize(21);
         out[0] = 0x00;
         memcpy(&out[1], &keyID, 20);
         return true;
     }
     CScriptID scriptID;
-    if (IsToScriptID(scriptID)) {
+    if (IsToScriptID(script, scriptID)) {
         out.resize(21);
         out[0] = 0x01;
         memcpy(&out[1], &scriptID, 20);
         return true;
     }
     CPubKey pubkey;
-    if (IsToPubKey(pubkey)) {
+    if (IsToPubKey(script, pubkey)) {
         out.resize(33);
         memcpy(&out[1], &pubkey[1], 32);
         if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
@@ -76,7 +84,7 @@ bool CScriptCompressor::Compress(std::vector<unsigned char> &out) const
     return false;
 }
 
-unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const
+unsigned int GetSpecialScriptSize(unsigned int nSize)
 {
     if (nSize == 0 || nSize == 1)
         return 20;
@@ -85,7 +93,7 @@ unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const
     return 0;
 }
 
-bool CScriptCompressor::Decompress(unsigned int nSize, const std::vector<unsigned char> &in)
+bool DecompressScript(CScript& script, unsigned int nSize, const std::vector<unsigned char> &in)
 {
     switch(nSize) {
     case 0x00:
@@ -139,7 +147,7 @@ bool CScriptCompressor::Decompress(unsigned int nSize, const std::vector<unsigne
 // * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n - 1) + 9
 // (this is decodable, as d is in [1-9] and e is in [0-9])
 
-uint64_t CTxOutCompressor::CompressAmount(uint64_t n)
+uint64_t CompressAmount(uint64_t n)
 {
     if (n == 0)
         return 0;
@@ -158,7 +166,7 @@ uint64_t CTxOutCompressor::CompressAmount(uint64_t n)
     }
 }
 
-uint64_t CTxOutCompressor::DecompressAmount(uint64_t x)
+uint64_t DecompressAmount(uint64_t x)
 {
     // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9
     if (x == 0)
diff --git a/src/compressor.h b/src/compressor.h
index 95699850817..892ba6f53f4 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -14,6 +14,13 @@ class CKeyID;
 class CPubKey;
 class CScriptID;
 
+bool CompressScript(const CScript& script, std::vector<unsigned char> &out);
+unsigned int GetSpecialScriptSize(unsigned int nSize);
+bool DecompressScript(CScript& script, unsigned int nSize, const std::vector<unsigned char> &out);
+
+uint64_t CompressAmount(uint64_t nAmount);
+uint64_t DecompressAmount(uint64_t nAmount);
+
 /** Compact serializer for scripts.
  *
  *  It detects common cases and encodes them much more efficiently.
@@ -37,28 +44,13 @@ class CScriptCompressor
     static const unsigned int nSpecialScripts = 6;
 
     CScript &script;
-protected:
-    /**
-     * These check for scripts for which a special case with a shorter encoding is defined.
-     * They are implemented separately from the CScript test, as these test for exact byte
-     * sequence correspondences, and are more strict. For example, IsToPubKey also verifies
-     * whether the public key is valid (as invalid ones cannot be represented in compressed
-     * form).
-     */
-    bool IsToKeyID(CKeyID &hash) const;
-    bool IsToScriptID(CScriptID &hash) const;
-    bool IsToPubKey(CPubKey &pubkey) const;
-
-    bool Compress(std::vector<unsigned char> &out) const;
-    unsigned int GetSpecialSize(unsigned int nSize) const;
-    bool Decompress(unsigned int nSize, const std::vector<unsigned char> &out);
 public:
     CScriptCompressor(CScript &scriptIn) : script(scriptIn) { }
 
     template<typename Stream>
     void Serialize(Stream &s) const {
         std::vector<unsigned char> compr;
-        if (Compress(compr)) {
+        if (CompressScript(script, compr)) {
             s << FlatVector(compr);
             return;
         }
@@ -72,9 +64,9 @@ class CScriptCompressor
         unsigned int nSize = 0;
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
-            std::vector<unsigned char> vch(GetSpecialSize(nSize), 0x00);
+            std::vector<unsigned char> vch(GetSpecialScriptSize(nSize), 0x00);
             s >> FlatVector(vch);
-            Decompress(nSize, vch);
+            DecompressScript(script, nSize, vch);
             return;
         }
         nSize -= nSpecialScripts;
@@ -96,9 +88,6 @@ class CTxOutCompressor
     CTxOut &txout;
 
 public:
-    static uint64_t CompressAmount(uint64_t nAmount);
-    static uint64_t DecompressAmount(uint64_t nAmount);
-
     CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
 
     ADD_SERIALIZE_METHODS;
diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp
index 35e4458bba7..3d5defd7624 100644
--- a/src/test/compress_tests.cpp
+++ b/src/test/compress_tests.cpp
@@ -25,16 +25,16 @@
 BOOST_FIXTURE_TEST_SUITE(compress_tests, BasicTestingSetup)
 
 bool static TestEncode(uint64_t in) {
-    return in == CTxOutCompressor::DecompressAmount(CTxOutCompressor::CompressAmount(in));
+    return in == DecompressAmount(CompressAmount(in));
 }
 
 bool static TestDecode(uint64_t in) {
-    return in == CTxOutCompressor::CompressAmount(CTxOutCompressor::DecompressAmount(in));
+    return in == CompressAmount(DecompressAmount(in));
 }
 
 bool static TestPair(uint64_t dec, uint64_t enc) {
-    return CTxOutCompressor::CompressAmount(dec) == enc &&
-           CTxOutCompressor::DecompressAmount(enc) == dec;
+    return CompressAmount(dec) == enc &&
+           DecompressAmount(enc) == dec;
 }
 
 BOOST_AUTO_TEST_CASE(compress_amounts)

From ab44006ba2b4bc1ddf1f48c6da1ad5a09de8f9ac Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 17:03:33 -0700
Subject: [PATCH 19/26] Convert compressor/txdb/coins/undo/script to new
 serialization

---
 src/coins.h                     |  6 ++--
 src/compressor.h                | 59 ++++++++++++++++++++------------------
 src/script/script.h             |  7 +----
 src/test/test_bitcoin_fuzzy.cpp |  3 +-
 src/txdb.cpp                    | 16 ++---------
 src/txdb.h                      | 10 +++----
 src/undo.h                      | 63 +++++++++--------------------------------
 7 files changed, 56 insertions(+), 108 deletions(-)

diff --git a/src/coins.h b/src/coins.h
index efb5ce869c3..be264ec6ae1 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -24,7 +24,7 @@
  *
  * Serialized format:
  * - VARINT((coinbase ? 1 : 0) | (height << 1))
- * - the non-spent CTxOut (via CTxOutCompressor)
+ * - the non-spent CTxOut (via TxOutCompress)
  */
 class Coin
 {
@@ -60,7 +60,7 @@ class Coin
         assert(!IsSpent());
         uint32_t code = nHeight * 2 + fCoinBase;
         ::Serialize(s, VARINT(code));
-        ::Serialize(s, CTxOutCompressor(REF(out)));
+        ::Serialize(s, TxOutCompress(out));
     }
 
     template<typename Stream>
@@ -69,7 +69,7 @@ class Coin
         ::Unserialize(s, VARINT(code));
         nHeight = code >> 1;
         fCoinBase = code & 1;
-        ::Unserialize(s, REF(CTxOutCompressor(out)));
+        ::Unserialize(s, TxOutCompress(out));
     }
 
     bool IsSpent() const {
diff --git a/src/compressor.h b/src/compressor.h
index 892ba6f53f4..3a59f6ba257 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -10,10 +10,6 @@
 #include "script/script.h"
 #include "serialize.h"
 
-class CKeyID;
-class CPubKey;
-class CScriptID;
-
 bool CompressScript(const CScript& script, std::vector<unsigned char> &out);
 unsigned int GetSpecialScriptSize(unsigned int nSize);
 bool DecompressScript(CScript& script, unsigned int nSize, const std::vector<unsigned char> &out);
@@ -32,7 +28,8 @@ uint64_t DecompressAmount(uint64_t nAmount);
  *  Other scripts up to 121 bytes require 1 byte + script length. Above
  *  that, scripts up to 16505 bytes require 2 bytes + script length.
  */
-class CScriptCompressor
+template<typename S>
+class ScriptCompressionWrapper
 {
 private:
     /**
@@ -43,9 +40,9 @@ class CScriptCompressor
      */
     static const unsigned int nSpecialScripts = 6;
 
-    CScript &script;
+    S &script;
 public:
-    CScriptCompressor(CScript &scriptIn) : script(scriptIn) { }
+    ScriptCompressionWrapper(S &scriptIn) : script(scriptIn) { }
 
     template<typename Stream>
     void Serialize(Stream &s) const {
@@ -81,30 +78,38 @@ class CScriptCompressor
     }
 };
 
-/** wrapper for CTxOut that provides a more compact serialization */
-class CTxOutCompressor
+template<typename I>
+class AmountCompressionWrapper
 {
-private:
-    CTxOut &txout;
-
+    I& m_val;
 public:
-    CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
+    AmountCompressionWrapper(I& val) : m_val(val) {}
+    template<typename Stream> void Serialize(Stream& s) const
+    {
+        s << VARINT(CompressAmount(m_val));
+    }
+    template<typename Stream> void Unserialize(Stream& s)
+    {
+        uint64_t v;
+        s >> VARINT(v);
+        m_val = DecompressAmount(v);
+    }
+};
 
-    ADD_SERIALIZE_METHODS;
+template<typename S> ScriptCompressionWrapper<S> ScriptCompress(S& s) { return ScriptCompressionWrapper<S>(s); }
+template<typename I> AmountCompressionWrapper<I> AmountCompress(I& i) { return AmountCompressionWrapper<I>(i); }
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        if (!ser_action.ForRead()) {
-            uint64_t nVal = CompressAmount(txout.nValue);
-            READWRITE(VARINT(nVal));
-        } else {
-            uint64_t nVal = 0;
-            READWRITE(VARINT(nVal));
-            txout.nValue = DecompressAmount(nVal);
-        }
-        CScriptCompressor cscript(REF(txout.scriptPubKey));
-        READWRITE(cscript);
-    }
+/** wrapper for CTxOut that provides a more compact serialization */
+template<typename O>
+class TxOutCompressionWrapper
+{
+private:
+    O &txout;
+public:
+    TxOutCompressionWrapper(O &txoutIn) : txout(txoutIn) { }
+    SERIALIZE_METHODS(obj) { READWRITE(AmountCompress(obj.txout.nValue), ScriptCompress(obj.txout.scriptPubKey)); }
 };
 
+template<typename O> TxOutCompressionWrapper<O> TxOutCompress(O& o) { return TxOutCompressionWrapper<O>(o); }
+
 #endif // BITCOIN_COMPRESSOR_H
diff --git a/src/script/script.h b/src/script/script.h
index 711ffa97f81..e0eb7df2b66 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -405,12 +405,7 @@ class CScript : public CScriptBase
     CScript(std::vector<unsigned char>::const_iterator pbegin, std::vector<unsigned char>::const_iterator pend) : CScriptBase(pbegin, pend) { }
     CScript(const unsigned char* pbegin, const unsigned char* pend) : CScriptBase(pbegin, pend) { }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(static_cast<CScriptBase&>(*this));
-    }
+    SERIALIZE_METHODS(obj) { READWRITEAS(obj, CScriptBase); }
 
     CScript& operator+=(const CScript& b)
     {
diff --git a/src/test/test_bitcoin_fuzzy.cpp b/src/test/test_bitcoin_fuzzy.cpp
index de142516013..de18e178fb5 100644
--- a/src/test/test_bitcoin_fuzzy.cpp
+++ b/src/test/test_bitcoin_fuzzy.cpp
@@ -241,10 +241,9 @@ int do_fuzz()
         case CTXOUTCOMPRESSOR_DESERIALIZE:
         {
             CTxOut to;
-            CTxOutCompressor toc(to);
             try
             {
-                ds >> toc;
+                ds >> TxOutCompress(to);
             } catch (const std::ios_base::failure& e) {return 0;}
 
             break;
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 4c1b04cd945..d183583ed0d 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -37,19 +37,7 @@ struct CoinEntry {
     char key;
     CoinEntry(const COutPoint* ptr) : outpoint(const_cast<COutPoint*>(ptr)), key(DB_COIN)  {}
 
-    template<typename Stream>
-    void Serialize(Stream &s) const {
-        s << key;
-        s << outpoint->hash;
-        s << VARINT(outpoint->n);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        s >> key;
-        s >> outpoint->hash;
-        s >> VARINT(outpoint->n);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.key, obj.outpoint->hash, VARINT(obj.outpoint->n)); }
 };
 
 }
@@ -348,7 +336,7 @@ class CCoins
         vout.assign(vAvail.size(), CTxOut());
         for (unsigned int i = 0; i < vAvail.size(); i++) {
             if (vAvail[i])
-                ::Unserialize(s, REF(CTxOutCompressor(vout[i])));
+                ::Unserialize(s, TxOutCompress(vout[i]));
         }
         // coinbase height
         ::Unserialize(s, VARINT(nHeight));
diff --git a/src/txdb.h b/src/txdb.h
index adcbc73380d..316773551db 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -42,12 +42,10 @@ struct CDiskTxPos : public CDiskBlockPos
 {
     unsigned int nTxOffset; // after header
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(*(CDiskBlockPos*)this);
-        READWRITE(VARINT(nTxOffset));
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITEAS(obj, CDiskBlockPos);
+        READWRITE(VARINT(obj.nTxOffset));
     }
 
     CDiskTxPos(const CDiskBlockPos &blockIn, unsigned int nTxOffsetIn) : CDiskBlockPos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
diff --git a/src/undo.h b/src/undo.h
index 0f9d041bbdc..e058ff711f3 100644
--- a/src/undo.h
+++ b/src/undo.h
@@ -18,51 +18,41 @@
  *  zero. This is be compatible with older versions which expect to see
  *  the transaction version there.
  */
-class TxInUndoSerializer
+template<typename C>
+class TxInUndoWrapper
 {
-    const Coin* txout;
+    C& txout;
 
 public:
     template<typename Stream>
     void Serialize(Stream &s) const {
-        ::Serialize(s, VARINT(txout->nHeight * 2 + (txout->fCoinBase ? 1 : 0)));
-        if (txout->nHeight > 0) {
+        ::Serialize(s, VARINT(txout.nHeight * 2 + (txout.fCoinBase ? 1 : 0)));
+        if (txout.nHeight > 0) {
             // Required to maintain compatibility with older undo format.
             ::Serialize(s, (unsigned char)0);
         }
-        ::Serialize(s, CTxOutCompressor(REF(txout->out)));
+        ::Serialize(s, TxOutCompress(txout.out));
     }
 
-    TxInUndoSerializer(const Coin* coin) : txout(coin) {}
-};
-
-class TxInUndoDeserializer
-{
-    Coin* txout;
-
-public:
     template<typename Stream>
     void Unserialize(Stream &s) {
         unsigned int nCode = 0;
         ::Unserialize(s, VARINT(nCode));
-        txout->nHeight = nCode / 2;
-        txout->fCoinBase = nCode & 1;
-        if (txout->nHeight > 0) {
+        txout.nHeight = nCode / 2;
+        txout.fCoinBase = nCode & 1;
+        if (txout.nHeight > 0) {
             // Old versions stored the version number for the last spend of
             // a transaction's outputs. Non-final spends were indicated with
             // height = 0.
             int nVersionDummy;
             ::Unserialize(s, VARINT(nVersionDummy));
         }
-        ::Unserialize(s, REF(CTxOutCompressor(REF(txout->out))));
+        ::Unserialize(s, TxOutCompress(txout.out));
     }
 
-    TxInUndoDeserializer(Coin* coin) : txout(coin) {}
+    TxInUndoWrapper(C& coin) : txout(coin) {}
 };
 
-static const size_t MIN_TRANSACTION_INPUT_WEIGHT = WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxIn(), SER_NETWORK, PROTOCOL_VERSION);
-static const size_t MAX_INPUTS_PER_BLOCK = MAX_BLOCK_WEIGHT / MIN_TRANSACTION_INPUT_WEIGHT;
-
 /** Undo information for a CTransaction */
 class CTxUndo
 {
@@ -70,29 +60,7 @@ class CTxUndo
     // undo information for all txins
     std::vector<Coin> vprevout;
 
-    template <typename Stream>
-    void Serialize(Stream& s) const {
-        // TODO: avoid reimplementing vector serializer
-        uint64_t count = vprevout.size();
-        ::Serialize(s, COMPACTSIZE(REF(count)));
-        for (const auto& prevout : vprevout) {
-            ::Serialize(s, REF(TxInUndoSerializer(&prevout)));
-        }
-    }
-
-    template <typename Stream>
-    void Unserialize(Stream& s) {
-        // TODO: avoid reimplementing vector deserializer
-        uint64_t count = 0;
-        ::Unserialize(s, COMPACTSIZE(count));
-        if (count > MAX_INPUTS_PER_BLOCK) {
-            throw std::ios_base::failure("Too many input undo records");
-        }
-        vprevout.resize(count);
-        for (auto& prevout : vprevout) {
-            ::Unserialize(s, REF(TxInUndoDeserializer(&prevout)));
-        }
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(VectorApply<TxInUndoWrapper>(obj.vprevout)); }
 };
 
 /** Undo information for a CBlock */
@@ -101,12 +69,7 @@ class CBlockUndo
 public:
     std::vector<CTxUndo> vtxundo; // for all but the coinbase
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(vtxundo);
-    }
+    SERIALIZE_METHODS(obj) { READWRITE(obj.vtxundo); }
 };
 
 #endif // BITCOIN_UNDO_H

From d80e98622730451de9370ca97957014de073e50b Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 17:58:36 -0700
Subject: [PATCH 20/26] Convert Qt to new serialization

---
 src/qt/recentrequeststablemodel.h | 22 +++++++++++-----------
 src/qt/walletmodel.h              | 39 ++++++++++++++++++---------------------
 2 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/src/qt/recentrequeststablemodel.h b/src/qt/recentrequeststablemodel.h
index 0c02968f928..9bd12d9ac39 100644
--- a/src/qt/recentrequeststablemodel.h
+++ b/src/qt/recentrequeststablemodel.h
@@ -24,19 +24,19 @@ class RecentRequestEntry
     QDateTime date;
     SendCoinsRecipient recipient;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
         unsigned int nDate = date.toTime_t();
+        s << this->nVersion << id << nDate << recipient;
+    }
 
-        READWRITE(this->nVersion);
-        READWRITE(id);
-        READWRITE(nDate);
-        READWRITE(recipient);
-
-        if (ser_action.ForRead())
-            date = QDateTime::fromTime_t(nDate);
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        unsigned int nDate;
+        s >> this->nVersion >> id >> nDate >> recipient;
+        date = QDateTime::fromTime_t(nDate);
     }
 };
 
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 6be36a57e25..492b3c8b777 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -62,35 +62,32 @@ class SendCoinsRecipient
     static const int CURRENT_VERSION = 1;
     int nVersion;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
         std::string sAddress = address.toStdString();
         std::string sLabel = label.toStdString();
         std::string sMessage = message.toStdString();
         std::string sPaymentRequest;
-        if (!ser_action.ForRead() && paymentRequest.IsInitialized())
+        if (paymentRequest.IsInitialized()) {
             paymentRequest.SerializeToString(&sPaymentRequest);
+        }
         std::string sAuthenticatedMerchant = authenticatedMerchant.toStdString();
+        s << this->nVersion << sAddress << sLabel << amount << sMessage << sPaymentRequest << sAuthenticatedMerchant;
+    }
 
-        READWRITE(this->nVersion);
-        READWRITE(sAddress);
-        READWRITE(sLabel);
-        READWRITE(amount);
-        READWRITE(sMessage);
-        READWRITE(sPaymentRequest);
-        READWRITE(sAuthenticatedMerchant);
-
-        if (ser_action.ForRead())
-        {
-            address = QString::fromStdString(sAddress);
-            label = QString::fromStdString(sLabel);
-            message = QString::fromStdString(sMessage);
-            if (!sPaymentRequest.empty())
-                paymentRequest.parse(QByteArray::fromRawData(sPaymentRequest.data(), sPaymentRequest.size()));
-            authenticatedMerchant = QString::fromStdString(sAuthenticatedMerchant);
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        std::string sAddress, sLabel, sMessage, sPaymentRequest, sAuthenticatedMerchant;
+        s >> this->nVersion >> sAddress >> sLabel >> amount >> sMessage >> sPaymentRequest >> sAuthenticatedMerchant;
+        address = QString::fromStdString(sAddress);
+        label = QString::fromStdString(sLabel);
+        message = QString::fromStdString(sMessage);
+        if (!sPaymentRequest.empty()) {
+            paymentRequest.parse(QByteArray::fromRawData(sPaymentRequest.data(), sPaymentRequest.size()));
         }
+        authenticatedMerchant = QString::fromStdString(sAuthenticatedMerchant);
     }
 };
 

From d04d26057ccbfdc8b25f4dc79d444e30d89542a0 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 18:01:03 -0700
Subject: [PATCH 21/26] Convert rest to new serialization

---
 src/rest.cpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/rest.cpp b/src/rest.cpp
index 6a4b005f908..9156cf994e8 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -45,18 +45,13 @@ struct CCoin {
     uint32_t nHeight;
     CTxOut out;
 
-    ADD_SERIALIZE_METHODS;
-
     CCoin() : nHeight(0) {}
     CCoin(Coin&& in) : nHeight(in.nHeight), out(std::move(in.out)) {}
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
+    SERIALIZE_METHODS(obj)
     {
         uint32_t nTxVerDummy = 0;
-        READWRITE(nTxVerDummy);
-        READWRITE(nHeight);
-        READWRITE(out);
+        READWRITE(nTxVerDummy, obj.nHeight, obj.out);
     }
 };
 

From 7e794fca36b8eff71427b59773eefc70a1bcb3dc Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 18:18:58 -0700
Subject: [PATCH 22/26] Convert dbwrapper tests to new serialization

---
 src/test/dbwrapper_tests.cpp | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/test/dbwrapper_tests.cpp b/src/test/dbwrapper_tests.cpp
index 6ed6e7744e3..bea4d307516 100644
--- a/src/test/dbwrapper_tests.cpp
+++ b/src/test/dbwrapper_tests.cpp
@@ -239,24 +239,26 @@ struct StringContentsSerializer {
     }
     StringContentsSerializer& operator+=(const StringContentsSerializer& s) { return *this += s.str; }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        if (ser_action.ForRead()) {
-            str.clear();
-            char c = 0;
-            while (true) {
-                try {
-                    READWRITE(c);
-                    str.push_back(c);
-                } catch (const std::ios_base::failure& e) {
-                    break;
-                }
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
+        for (size_t i = 0; i < str.size(); i++) {
+            s << str[i];
+        }
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        str.clear();
+        char c = 0;
+        while (true) {
+            try {
+                s >> c;
+                str.push_back(c);
+            } catch (const std::ios_base::failure& e) {
+                break;
             }
-        } else {
-            for (size_t i = 0; i < str.size(); i++)
-                READWRITE(str[i]);
         }
     }
 };

From fb63c01bd71c4db336f5e04a13ed69ee957df27c Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 18:21:07 -0700
Subject: [PATCH 23/26] Convert serialize_tests to new serialization

---
 src/test/serialize_tests.cpp | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index 36af6de88ea..d65bb617e31 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -24,15 +24,14 @@ class CSerializeMethodsTestSingle
 public:
     CSerializeMethodsTestSingle() = default;
     CSerializeMethodsTestSingle(int intvalin, bool boolvalin, std::string stringvalin, const char* charstrvalin, CTransaction txvalin) : intval(intvalin), boolval(boolvalin), stringval(std::move(stringvalin)), charstrval(charstrvalin), txval(MakeTransactionRef(txvalin)){}
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(intval);
-        READWRITE(boolval);
-        READWRITE(stringval);
-        READWRITE(FLATDATA(charstrval));
-        READWRITE(txval);
+
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(obj.intval);
+        READWRITE(obj.boolval);
+        READWRITE(obj.stringval);
+        READWRITE(FLATDATA(obj.charstrval));
+        READWRITE(obj.txval);
     }
 
     bool operator==(const CSerializeMethodsTestSingle& rhs)
@@ -49,11 +48,10 @@ 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, FLATDATA(charstrval), txval);
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(obj.intval, obj.boolval, obj.stringval, FLATDATA(obj.charstrval), obj.txval);
     }
 };
 

From 5531fd4af408c4c93bc78b7580ecd47a3835c1bb Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 23:20:11 -0700
Subject: [PATCH 24/26] Convert wallet/walletdb/crypter to new serialization

---
 src/wallet/crypter.h  |  12 +--
 src/wallet/wallet.h   | 199 +++++++++++++++++++++++---------------------------
 src/wallet/walletdb.h |  29 +++-----
 3 files changed, 106 insertions(+), 134 deletions(-)

diff --git a/src/wallet/crypter.h b/src/wallet/crypter.h
index 1dc44e424f6..f9e2ea3a002 100644
--- a/src/wallet/crypter.h
+++ b/src/wallet/crypter.h
@@ -42,15 +42,9 @@ class CMasterKey
     //! such as the various parameters to scrypt
     std::vector<unsigned char> vchOtherDerivationParameters;
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(vchCryptedKey);
-        READWRITE(vchSalt);
-        READWRITE(nDerivationMethod);
-        READWRITE(nDeriveIterations);
-        READWRITE(vchOtherDerivationParameters);
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(obj.vchCryptedKey, obj.vchSalt, obj.nDerivationMethod, obj.nDeriveIterations, obj.vchOtherDerivationParameters);
     }
 
     CMasterKey()
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index f97a99d82a1..d2d9f6a7e67 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -111,27 +111,30 @@ class CKeyPool
     CKeyPool();
     CKeyPool(const CPubKey& vchPubKeyIn, bool internalIn);
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
         int nVersion = s.GetVersion();
-        if (!(s.GetType() & SER_GETHASH))
-            READWRITE(nVersion);
-        READWRITE(nTime);
-        READWRITE(vchPubKey);
-        if (ser_action.ForRead()) {
-            try {
-                READWRITE(fInternal);
-            }
-            catch (std::ios_base::failure&) {
-                /* flag as external address if we can't read the internal boolean
-                   (this will be the case for any wallet before the HD chain split version) */
-                fInternal = false;
-            }
+        if (!(s.GetType() & SER_GETHASH)) {
+            s << nVersion;
         }
-        else {
-            READWRITE(fInternal);
+        s << nTime << vchPubKey << fInternal;
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        int nVersion;
+        if (!(s.GetType() & SER_GETHASH)) {
+            s >> nVersion;
+        }
+        s >> nTime >> vchPubKey;
+        try {
+            s >> fInternal;
+        } catch (std::ios_base::failure&) {
+            /* flag as external address if we can't read the internal boolean
+               (this will be the case for any wallet before the HD chain split version) */
+            fInternal = false;
         }
     }
 };
@@ -229,15 +232,10 @@ class CMerkleTx
         tx = std::move(arg);
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    SERIALIZE_METHODS(obj)
+    {
         std::vector<uint256> vMerkleBranch; // For compatibility with older versions.
-        READWRITE(tx);
-        READWRITE(hashBlock);
-        READWRITE(vMerkleBranch);
-        READWRITE(nIndex);
+        READWRITE(obj.tx, obj.hashBlock, vMerkleBranch, obj.nIndex);
     }
 
     void SetMerkleBranch(const CBlockIndex* pIndex, int posInBlock);
@@ -381,42 +379,36 @@ class CWalletTx : public CMerkleTx
         nOrderPos = -1;
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        if (ser_action.ForRead())
-            Init(nullptr);
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
         char fSpent = false;
+        mapValue_t mapValueCopy = mapValue;
 
-        if (!ser_action.ForRead())
-        {
-            mapValue["fromaccount"] = strFromAccount;
-
-            WriteOrderPos(nOrderPos, mapValue);
-
-            if (nTimeSmart)
-                mapValue["timesmart"] = strprintf("%u", nTimeSmart);
+        mapValueCopy["fromaccount"] = strFromAccount;
+        WriteOrderPos(nOrderPos, mapValueCopy);
+        if (nTimeSmart) {
+            mapValueCopy["timesmart"] = strprintf("%u", nTimeSmart);
         }
 
-        READWRITE(*(CMerkleTx*)this);
+        s << AsBaseType<CMerkleTx>(*this);
         std::vector<CMerkleTx> vUnused; //!< Used to be vtxPrev
-        READWRITE(vUnused);
-        READWRITE(mapValue);
-        READWRITE(vOrderForm);
-        READWRITE(fTimeReceivedIsTxTime);
-        READWRITE(nTimeReceived);
-        READWRITE(fFromMe);
-        READWRITE(fSpent);
-
-        if (ser_action.ForRead())
-        {
-            strFromAccount = mapValue["fromaccount"];
+        s << vUnused << mapValueCopy << vOrderForm << fTimeReceivedIsTxTime << nTimeReceived << fFromMe << fSpent;
+    }
 
-            ReadOrderPos(nOrderPos, mapValue);
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        Init(nullptr);
+        char fSpent;
 
-            nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(mapValue["timesmart"]) : 0;
-        }
+        s >> AsBaseType<CMerkleTx>(*this);
+        std::vector<CMerkleTx> vUnused; //!< Used to be vtxPrev
+        s >> vUnused >> mapValue >> vOrderForm >> fTimeReceivedIsTxTime >> nTimeReceived >> fFromMe >> fSpent;
+
+        strFromAccount = mapValue["fromaccount"];
+        ReadOrderPos(nOrderPos, mapValue);
+        nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(mapValue["timesmart"]) : 0;
 
         mapValue.erase("fromaccount");
         mapValue.erase("spent");
@@ -550,17 +542,13 @@ class CWalletKey
 
     CWalletKey(int64_t nExpires=0);
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    SERIALIZE_METHODS(obj)
+    {
         int nVersion = s.GetVersion();
-        if (!(s.GetType() & SER_GETHASH))
+        if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(nVersion);
-        READWRITE(vchPrivKey);
-        READWRITE(nTimeCreated);
-        READWRITE(nTimeExpires);
-        READWRITE(LIMITED_STRING(strComment, 65536));
+        }
+        READWRITE(obj.vchPrivKey, obj.nTimeCreated, obj.nTimeExpires, LIMITED_STRING(obj.strComment, 65536));
     }
 };
 
@@ -596,49 +584,47 @@ class CAccountingEntry
         nEntryNo = 0;
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
         int nVersion = s.GetVersion();
-        if (!(s.GetType() & SER_GETHASH))
-            READWRITE(nVersion);
+        if (!(s.GetType() & SER_GETHASH)) {
+            s << nVersion;
+        }
         //! Note: strAccount is serialized as part of the key, not here.
-        READWRITE(nCreditDebit);
-        READWRITE(nTime);
-        READWRITE(LIMITED_STRING(strOtherAccount, 65536));
-
-        if (!ser_action.ForRead())
-        {
-            WriteOrderPos(nOrderPos, mapValue);
-
-            if (!(mapValue.empty() && _ssExtra.empty()))
-            {
-                CDataStream ss(s.GetType(), s.GetVersion());
-                ss.insert(ss.begin(), '\0');
-                ss << mapValue;
-                ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end());
-                strComment.append(ss.str());
-            }
+        s << nCreditDebit << nTime << LIMITED_STRING(strOtherAccount, 65536);
+        mapValue_t mapValueCopy = mapValue;
+        std::string strCommentCopy = strComment;
+        WriteOrderPos(nOrderPos, mapValueCopy);
+        if (!(mapValueCopy.empty() && _ssExtra.empty())) {
+            CDataStream ss(s.GetType(), s.GetVersion());
+            ss.insert(ss.begin(), '\0');
+            ss << mapValueCopy;
+            ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end());
+            strCommentCopy.append(ss.str());
         }
+        s << LIMITED_STRING(strCommentCopy, 65536);
+    }
 
-        READWRITE(LIMITED_STRING(strComment, 65536));
-
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        int nVersion = s.GetVersion();
+        if (!(s.GetType() & SER_GETHASH)) {
+            s >> nVersion;
+        }
+        s >> nCreditDebit >> nTime >> LIMITED_STRING(strOtherAccount, 65536) >> LIMITED_STRING(strComment, 65536);
         size_t nSepPos = strComment.find("\0", 0, 1);
-        if (ser_action.ForRead())
-        {
-            mapValue.clear();
-            if (std::string::npos != nSepPos)
-            {
-                CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), s.GetType(), s.GetVersion());
-                ss >> mapValue;
-                _ssExtra = std::vector<char>(ss.begin(), ss.end());
-            }
-            ReadOrderPos(nOrderPos, mapValue);
+        mapValue.clear();
+        if (std::string::npos != nSepPos) {
+            CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), s.GetType(), s.GetVersion());
+            ss >> mapValue;
+            _ssExtra = std::vector<char>(ss.begin(), ss.end());
         }
-        if (std::string::npos != nSepPos)
+        ReadOrderPos(nOrderPos, mapValue);
+        if (std::string::npos != nSepPos) {
             strComment.erase(nSepPos);
-
+        }
         mapValue.erase("n");
     }
 
@@ -1187,14 +1173,13 @@ class CAccount
         vchPubKey = CPubKey();
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    SERIALIZE_METHODS(obj)
+    {
         int nVersion = s.GetVersion();
-        if (!(s.GetType() & SER_GETHASH))
+        if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(nVersion);
-        READWRITE(vchPubKey);
+        }
+        READWRITE(obj.vchPubKey);
     }
 };
 
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index d78f143ebd6..3bf1cb70628 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -70,15 +70,13 @@ class CHDChain
     int nVersion;
 
     CHDChain() { SetNull(); }
-    ADD_SERIALIZE_METHODS;
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
+
+    SERIALIZE_METHODS(obj)
     {
-        READWRITE(this->nVersion);
-        READWRITE(nExternalChainCounter);
-        READWRITE(masterKeyID);
-        if (this->nVersion >= VERSION_HD_CHAIN_SPLIT)
-            READWRITE(nInternalChainCounter);
+        READWRITE(obj.nVersion, obj.nExternalChainCounter, obj.masterKeyID);
+        if (obj.nVersion >= VERSION_HD_CHAIN_SPLIT) {
+            READWRITE(obj.nInternalChainCounter);
+        }
     }
 
     void SetNull()
@@ -111,16 +109,11 @@ class CKeyMetadata
         nCreateTime = nCreateTime_;
     }
 
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(this->nVersion);
-        READWRITE(nCreateTime);
-        if (this->nVersion >= VERSION_WITH_HDDATA)
-        {
-            READWRITE(hdKeypath);
-            READWRITE(hdMasterKeyID);
+    SERIALIZE_METHODS(obj)
+    {
+        READWRITE(obj.nVersion, obj.nCreateTime);
+        if (obj.nVersion >= VERSION_WITH_HDDATA) {
+            READWRITE(obj.hdKeypath, obj.hdMasterKeyID);
         }
     }
 

From 313d0356c1db80f0d272c14d41346b81cba33781 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Fri, 7 Jul 2017 21:50:51 -0700
Subject: [PATCH 25/26] Convert netaddress to new serialization

---
 src/netaddress.h | 27 +++------------------------
 1 file changed, 3 insertions(+), 24 deletions(-)

diff --git a/src/netaddress.h b/src/netaddress.h
index 57ce897db5e..d8bd80b5528 100644
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -89,12 +89,7 @@ class CNetAddr
         friend bool operator!=(const CNetAddr& a, const CNetAddr& b);
         friend bool operator<(const CNetAddr& a, const CNetAddr& b);
 
-        ADD_SERIALIZE_METHODS;
-
-        template <typename Stream, typename Operation>
-        inline void SerializationOp(Stream& s, Operation ser_action) {
-            READWRITE(FLATDATA(ip));
-        }
+        SERIALIZE_METHODS(obj) { READWRITE(FLATDATA(obj.ip)); }
 
         friend class CSubNet;
 };
@@ -126,14 +121,7 @@ class CSubNet
         friend bool operator!=(const CSubNet& a, const CSubNet& b);
         friend bool operator<(const CSubNet& a, const CSubNet& b);
 
-        ADD_SERIALIZE_METHODS;
-
-        template <typename Stream, typename Operation>
-        inline void SerializationOp(Stream& s, Operation ser_action) {
-            READWRITE(network);
-            READWRITE(FLATDATA(netmask));
-            READWRITE(FLATDATA(valid));
-        }
+        SERIALIZE_METHODS(obj) { READWRITE(obj.network, FLATDATA(obj.netmask), FLATDATA(obj.valid)); }
 };
 
 /** A combination of a network address (CNetAddr) and a (TCP) port */
@@ -162,16 +150,7 @@ class CService : public CNetAddr
         CService(const struct in6_addr& ipv6Addr, unsigned short port);
         CService(const struct sockaddr_in6& addr);
 
-        ADD_SERIALIZE_METHODS;
-
-        template <typename Stream, typename Operation>
-        inline void SerializationOp(Stream& s, Operation ser_action) {
-            READWRITE(FLATDATA(ip));
-            unsigned short portN = htons(port);
-            READWRITE(FLATDATA(portN));
-            if (ser_action.ForRead())
-                 port = ntohs(portN);
-        }
+        SERIALIZE_METHODS(obj) { READWRITE(FLATDATA(obj.ip), BigEndian(obj.port)); }
 };
 
 #endif // BITCOIN_NETADDRESS_H

From a9a1375eb853dcb4fd2a4627335c9c0bdf13c7ef Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter.wuille@gmail.com>
Date: Sat, 8 Jul 2017 23:42:48 -0700
Subject: [PATCH 26/26] Remove old serialization primitives

---
 src/serialize.h | 36 ------------------------------------
 1 file changed, 36 deletions(-)

diff --git a/src/serialize.h b/src/serialize.h
index dcf1b5390ef..9ffd3a243b0 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -39,26 +39,6 @@ static const unsigned int MAX_SIZE = 0x02000000;
 struct deserialize_type {};
 constexpr deserialize_type deserialize {};
 
-/**
- * Used to bypass the rule against non-const reference to temporary
- * where it makes sense with wrappers such as CFlatData or CTxDB
- */
-template<typename T>
-inline T& REF(const T& val)
-{
-    return const_cast<T&>(val);
-}
-
-/**
- * Used to acquire a non-const pointer "this" to generate bodies
- * of const serialization operations from a template
- */
-template<typename T>
-inline T* NCONST_PTR(const T* val)
-{
-    return const_cast<T*>(val);
-}
-
 /*
  * Lowest-level serialization and conversion.
  * @note Sizes of these types are verified in the tests
@@ -173,22 +153,6 @@ template<typename X> const X&& AsBaseType(const X&& x) { return std::move(x); }
  */
 #define READWRITEAS(obj, typ) (::SerReadWriteMany(s, ser_action, AsBaseType<typ>(obj)))
 
-/** 
- * Implement three methods for serializable objects. These are actually wrappers over
- * "SerializationOp" template, which implements the body of each class' serialization
- * code. Adding "ADD_SERIALIZE_METHODS" in the body of the class causes these wrappers to be
- * added as members. 
- */
-#define ADD_SERIALIZE_METHODS                                         \
-    template<typename Stream>                                         \
-    void Serialize(Stream& s) const {                                 \
-        NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize());  \
-    }                                                                 \
-    template<typename Stream>                                         \
-    void Unserialize(Stream& s) {                                     \
-        SerializationOp(s, CSerActionUnserialize());                  \
-    }
-
 /**
  * Implement the Serialize and Unserialize methods by delegating to a single templated
  * static method that takes the to-be-(de)serialized object as a parameter. This approach