Merge #12683: Fix more constness violations in serialization code

sipa · sipa · commit 7be9a9a570c1 · 2018-03-15T16:57:55.000-07:00
172f5fa Support deserializing into temporaries (Pieter Wuille) 2761bca Merge READWRITEMANY into READWRITE (Pieter Wuille) Pull request description: This is another fragment of improvements from #10785. The current serialization code does not support serializing/deserializing from/to temporaries (like `s >> CFlatData(script)`). As a result, there are many invocations of the `REF` macro which in addition to changing the reference type also changes the constness. This is unnecessary in C++11 as we can use rvalue references now instead. The first commit is an extra simplification we can make that removes the duplication of code between `READWRITE` and `READWRITEMANY` (and related functions). Tree-SHA512: babfa9cb268cc3bc39917e4f0a90e4651c33d85032161e16547a07f3b257b7ca7940e0cbfd69f09439d26fafbb1a6cf6359101043407e2c7aeececf7f20b6eed
diff --git a/src/blockencodings.h b/src/blockencodings.h
@@ -90,11 +90,11 @@ class BlockTransactions {
             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])));
+                    READWRITE(TransactionCompressor(txn[i]));
             }
         } else {
             for (size_t i = 0; i < txn.size(); i++)
-                READWRITE(REF(TransactionCompressor(txn[i])));
+                READWRITE(TransactionCompressor(txn[i]));
         }
     }
 };
@@ -115,7 +115,7 @@ struct PrefilledTransaction {
         if (idx > std::numeric_limits<uint16_t>::max())
             throw std::ios_base::failure("index overflowed 16-bits");
         index = idx;
-        READWRITE(REF(TransactionCompressor(tx)));
+        READWRITE(TransactionCompressor(tx));
     }
 };
 
diff --git a/src/coins.h b/src/coins.h
@@ -69,7 +69,7 @@ class Coin
         ::Unserialize(s, VARINT(code));
         nHeight = code >> 1;
         fCoinBase = code & 1;
-        ::Unserialize(s, REF(CTxOutCompressor(out)));
+        ::Unserialize(s, CTxOutCompressor(out));
     }
 
     bool IsSpent() const {
diff --git a/src/compressor.h b/src/compressor.h
@@ -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 >> CFlatData(vch);
             Decompress(nSize, vch);
             return;
         }
@@ -84,7 +84,7 @@ class CScriptCompressor
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> REF(CFlatData(script));
+            s >> CFlatData(script);
         }
     }
 };
diff --git a/src/hash.h b/src/hash.h
@@ -173,7 +173,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
@@ -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
@@ -148,8 +148,7 @@ enum
     SER_GETHASH         = (1 << 2),
 };
 
-#define READWRITE(obj)      (::SerReadWrite(s, (obj), ser_action))
-#define READWRITEMANY(...)      (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
+#define READWRITE(...)      (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
 
 /** 
  * Implement three methods for serializable objects. These are actually wrappers over
@@ -351,10 +350,10 @@ 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)))
+#define FLATDATA(obj) CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj))
+#define VARINT(obj) WrapVarInt(REF(obj))
+#define COMPACTSIZE(obj) CCompactSize(REF(obj))
+#define LIMITED_STRING(obj,n) LimitedString< n >(REF(obj))
 
 /** 
  * Wrapper for serializing arrays and POD.
@@ -539,7 +538,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);
 }
@@ -825,19 +824,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);
-}
-
-
 
 
 
@@ -897,45 +883,33 @@ void SerializeMany(Stream& s)
 {
 }
 
-template<typename Stream, typename Arg>
-void SerializeMany(Stream& s, Arg&& arg)
-{
-    ::Serialize(s, std::forward<Arg>(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>
 inline void UnserializeMany(Stream& s)
 {
 }
 
-template<typename Stream, typename 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
@@ -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);
@@ -399,7 +399,7 @@ class CDataStream
     }
 
     template<typename T>
-    CDataStream& operator>>(T& obj)
+    CDataStream& operator>>(T&& obj)
     {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
@@ -543,7 +543,7 @@ class CAutoFile
     }
 
     template<typename T>
-    CAutoFile& operator>>(T& obj)
+    CAutoFile& operator>>(T&& obj)
     {
         // Unserialize from this stream
         if (!file)
@@ -686,7 +686,7 @@ class CBufferedFile
     }
 
     template<typename T>
-    CBufferedFile& operator>>(T& obj) {
+    CBufferedFile& operator>>(T&& obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
diff --git 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);
     }
 };
 
diff --git a/src/txdb.cpp b/src/txdb.cpp
@@ -348,7 +348,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, CTxOutCompressor(vout[i]));
         }
         // coinbase height
         ::Unserialize(s, VARINT(nHeight));
diff --git a/src/undo.h b/src/undo.h
@@ -54,7 +54,7 @@ class TxInUndoDeserializer
             int nVersionDummy;
             ::Unserialize(s, VARINT(nVersionDummy));
         }
-        ::Unserialize(s, REF(CTxOutCompressor(REF(txout->out))));
+        ::Unserialize(s, CTxOutCompressor(REF(txout->out)));
     }
 
     explicit TxInUndoDeserializer(Coin* coin) : txout(coin) {}
@@ -76,7 +76,7 @@ class CTxUndo
         uint64_t count = vprevout.size();
         ::Serialize(s, COMPACTSIZE(REF(count)));
         for (const auto& prevout : vprevout) {
-            ::Serialize(s, REF(TxInUndoSerializer(&prevout)));
+            ::Serialize(s, TxInUndoSerializer(&prevout));
         }
     }
 
@@ -90,7 +90,7 @@ class CTxUndo
         }
         vprevout.resize(count);
         for (auto& prevout : vprevout) {
-            ::Unserialize(s, REF(TxInUndoDeserializer(&prevout)));
+            ::Unserialize(s, TxInUndoDeserializer(&prevout));
         }
     }
 };

Original file line number	Diff line number	Diff line change
`@@ -90,11 +90,11 @@ class BlockTransactions {`
`90`	`90`	`while (txn.size() < txn_size) {`
`91`	`91`	`txn.resize(std::min((uint64_t)(1000 + txn.size()), txn_size));`
`92`	`92`	`for (; i < txn.size(); i++)`
`93`		`- READWRITE(REF(TransactionCompressor(txn[i])));`
	`93`	`+ READWRITE(TransactionCompressor(txn[i]));`
`94`	`94`	`}`
`95`	`95`	`} else {`
`96`	`96`	`for (size_t i = 0; i < txn.size(); i++)`
`97`		`- READWRITE(REF(TransactionCompressor(txn[i])));`
	`97`	`+ READWRITE(TransactionCompressor(txn[i]));`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`};`
`@@ -115,7 +115,7 @@ struct PrefilledTransaction {`
`115`	`115`	`if (idx > std::numeric_limits<uint16_t>::max())`
`116`	`116`	`throw std::ios_base::failure("index overflowed 16-bits");`
`117`	`117`	`index = idx;`
`118`		`- READWRITE(REF(TransactionCompressor(tx)));`
	`118`	`+ READWRITE(TransactionCompressor(tx));`
`119`	`119`	`}`
`120`	`120`	`};`
`121`	`121`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ class Coin`
`69`	`69`	`::Unserialize(s, VARINT(code));`
`70`	`70`	`nHeight = code >> 1;`
`71`	`71`	`fCoinBase = code & 1;`
`72`		`- ::Unserialize(s, REF(CTxOutCompressor(out)));`
	`72`	`+ ::Unserialize(s, CTxOutCompressor(out));`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`bool IsSpent() const {`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ class CScriptCompressor`
`73`	`73`	`s >> VARINT(nSize);`
`74`	`74`	`if (nSize < nSpecialScripts) {`
`75`	`75`	`std::vector<unsigned char> vch(GetSpecialSize(nSize), 0x00);`
`76`		`- s >> REF(CFlatData(vch));`
	`76`	`+ s >> CFlatData(vch);`
`77`	`77`	`Decompress(nSize, vch);`
`78`	`78`	`return;`
`79`	`79`	`}`
`@@ -84,7 +84,7 @@ class CScriptCompressor`
`84`	`84`	`s.ignore(nSize);`
`85`	`85`	`} else {`
`86`	`86`	`script.resize(nSize);`
`87`		`- s >> REF(CFlatData(script));`
	`87`	`+ s >> CFlatData(script);`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`};`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ class CHashVerifier : public CHashWriter`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`template<typename T>`
`176`		`- CHashVerifier<Source>& operator>>(T& obj)`
	`176`	`+ CHashVerifier<Source>& operator>>(T&& obj)`
`177`	`177`	`{`
`178`	`178`	`// Unserialize from this stream`
`179`	`179`	`::Unserialize(*this, obj);`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ class TxInputStream`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`template<typename T>`
`43`		`- TxInputStream& operator>>(T& obj)`
	`43`	`+ TxInputStream& operator>>(T&& obj)`
`44`	`44`	`{`
`45`	`45`	`::Unserialize(*this, obj);`
`46`	`46`	`return *this;`
Original file line number	Diff line number	Diff line change
`@@ -148,8 +148,7 @@ enum`
`148`	`148`	`SER_GETHASH = (1 << 2),`
`149`	`149`	`};`
`150`	`150`
`151`		`-#define READWRITE(obj) (::SerReadWrite(s, (obj), ser_action))`
`152`		`-#define READWRITEMANY(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))`
	`151`	`+#define READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))`
`153`	`152`
`154`	`153`	`/**`
`155`	`154`	`* Implement three methods for serializable objects. These are actually wrappers over`
`@@ -351,10 +350,10 @@ I ReadVarInt(Stream& is)`
`351`	`350`	`}`
`352`	`351`	`}`
`353`	`352`
`354`		`-#define FLATDATA(obj) REF(CFlatData((char)&(obj), (char)&(obj) + sizeof(obj)))`
`355`		`-#define VARINT(obj) REF(WrapVarInt(REF(obj)))`
`356`		`-#define COMPACTSIZE(obj) REF(CCompactSize(REF(obj)))`
`357`		`-#define LIMITED_STRING(obj,n) REF(LimitedString< n >(REF(obj)))`
	`353`	`+#define FLATDATA(obj) CFlatData((char)&(obj), (char)&(obj) + sizeof(obj))`
	`354`	`+#define VARINT(obj) WrapVarInt(REF(obj))`
	`355`	`+#define COMPACTSIZE(obj) CCompactSize(REF(obj))`
	`356`	`+#define LIMITED_STRING(obj,n) LimitedString< n >(REF(obj))`
`358`	`357`
`359`	`358`	`/**`
`360`	`359`	`* Wrapper for serializing arrays and POD.`
`@@ -539,7 +538,7 @@ inline void Serialize(Stream& os, const T& a)`
`539`	`538`	`}`
`540`	`539`
`541`	`540`	`template<typename Stream, typename T>`
`542`		`-inline void Unserialize(Stream& is, T& a)`
	`541`	`+inline void Unserialize(Stream& is, T&& a)`
`543`	`542`	`{`
`544`	`543`	`a.Unserialize(is);`
`545`	`544`	`}`
`@@ -825,19 +824,6 @@ struct CSerActionUnserialize`
`825`	`824`	`constexpr bool ForRead() const { return true; }`
`826`	`825`	`};`
`827`	`826`
`828`		`-template<typename Stream, typename T>`
`829`		`-inline void SerReadWrite(Stream& s, const T& obj, CSerActionSerialize ser_action)`
`830`		`-{`
`831`		`- ::Serialize(s, obj);`
`832`		`-}`
`833`		`-`
`834`		`-template<typename Stream, typename T>`
`835`		`-inline void SerReadWrite(Stream& s, T& obj, CSerActionUnserialize ser_action)`
`836`		`-{`
`837`		`- ::Unserialize(s, obj);`
`838`		`-}`
`839`		`-`
`840`		`-`
`841`	`827`
`842`	`828`
`843`	`829`
`@@ -897,45 +883,33 @@ void SerializeMany(Stream& s)`
`897`	`883`	`{`
`898`	`884`	`}`
`899`	`885`
`900`		`-template<typename Stream, typename Arg>`
`901`		`-void SerializeMany(Stream& s, Arg&& arg)`
`902`		`-{`
`903`		`- ::Serialize(s, std::forward<Arg>(arg));`
`904`		`-}`
`905`		`-`
`906`	`886`	`template<typename Stream, typename Arg, typename... Args>`
`907`		`-void SerializeMany(Stream& s, Arg&& arg, Args&&... args)`
	`887`	`+void SerializeMany(Stream& s, const Arg& arg, const Args&... args)`
`908`	`888`	`{`
`909`		`- ::Serialize(s, std::forward<Arg>(arg));`
`910`		`- ::SerializeMany(s, std::forward<Args>(args)...);`
	`889`	`+ ::Serialize(s, arg);`
	`890`	`+ ::SerializeMany(s, args...);`
`911`	`891`	`}`
`912`	`892`
`913`	`893`	`template<typename Stream>`
`914`	`894`	`inline void UnserializeMany(Stream& s)`
`915`	`895`	`{`
`916`	`896`	`}`
`917`	`897`
`918`		`-template<typename Stream, typename Arg>`
`919`		`-inline void UnserializeMany(Stream& s, Arg& arg)`
`920`		`-{`
`921`		`- ::Unserialize(s, arg);`
`922`		`-}`
`923`		`-`
`924`	`898`	`template<typename Stream, typename Arg, typename... Args>`
`925`		`-inline void UnserializeMany(Stream& s, Arg& arg, Args&... args)`
	`899`	`+inline void UnserializeMany(Stream& s, Arg&& arg, Args&&... args)`
`926`	`900`	`{`
`927`	`901`	`::Unserialize(s, arg);`
`928`	`902`	`::UnserializeMany(s, args...);`
`929`	`903`	`}`
`930`	`904`
`931`	`905`	`template<typename Stream, typename... Args>`
`932`		`-inline void SerReadWriteMany(Stream& s, CSerActionSerialize ser_action, Args&&... args)`
	`906`	`+inline void SerReadWriteMany(Stream& s, CSerActionSerialize ser_action, const Args&... args)`
`933`	`907`	`{`
`934`		`- ::SerializeMany(s, std::forward<Args>(args)...);`
	`908`	`+ ::SerializeMany(s, args...);`
`935`	`909`	`}`
`936`	`910`
`937`	`911`	`template<typename Stream, typename... Args>`
`938`		`-inline void SerReadWriteMany(Stream& s, CSerActionUnserialize ser_action, Args&... args)`
	`912`	`+inline void SerReadWriteMany(Stream& s, CSerActionUnserialize ser_action, Args&&... args)`
`939`	`913`	`{`
`940`	`914`	`::UnserializeMany(s, args...);`
`941`	`915`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ class OverrideStream`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`template<typename T>`
`45`		`- OverrideStream<Stream>& operator>>(T& obj)`
	`45`	`+ OverrideStream<Stream>& operator>>(T&& obj)`
`46`	`46`	`{`
`47`	`47`	`// Unserialize from this stream`
`48`	`48`	`::Unserialize(*this, obj);`
`@@ -399,7 +399,7 @@ class CDataStream`
`399`	`399`	`}`
`400`	`400`
`401`	`401`	`template<typename T>`
`402`		`- CDataStream& operator>>(T& obj)`
	`402`	`+ CDataStream& operator>>(T&& obj)`
`403`	`403`	`{`
`404`	`404`	`// Unserialize from this stream`
`405`	`405`	`::Unserialize(*this, obj);`
`@@ -543,7 +543,7 @@ class CAutoFile`
`543`	`543`	`}`
`544`	`544`
`545`	`545`	`template<typename T>`
`546`		`- CAutoFile& operator>>(T& obj)`
	`546`	`+ CAutoFile& operator>>(T&& obj)`
`547`	`547`	`{`
`548`	`548`	`// Unserialize from this stream`
`549`	`549`	`if (!file)`
`@@ -686,7 +686,7 @@ class CBufferedFile`
`686`	`686`	`}`
`687`	`687`
`688`	`688`	`template<typename T>`
`689`		`- CBufferedFile& operator>>(T& obj) {`
	`689`	`+ CBufferedFile& operator>>(T&& obj) {`
`690`	`690`	`// Unserialize from this stream`
`691`	`691`	`::Unserialize(*this, obj);`
`692`	`692`	`return (*this);`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle`
`53`	`53`
`54`	`54`	`template <typename Stream, typename Operation>`
`55`	`55`	`inline void SerializationOp(Stream& s, Operation ser_action) {`
`56`		`- READWRITEMANY(intval, boolval, stringval, FLATDATA(charstrval), txval);`
	`56`	`+ READWRITE(intval, boolval, stringval, FLATDATA(charstrval), txval);`
`57`	`57`	`}`
`58`	`58`	`};`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -348,7 +348,7 @@ class CCoins`
`348`	`348`	`vout.assign(vAvail.size(), CTxOut());`
`349`	`349`	`for (unsigned int i = 0; i < vAvail.size(); i++) {`
`350`	`350`	`if (vAvail[i])`
`351`		`- ::Unserialize(s, REF(CTxOutCompressor(vout[i])));`
	`351`	`+ ::Unserialize(s, CTxOutCompressor(vout[i]));`
`352`	`352`	`}`
`353`	`353`	`// coinbase height`
`354`	`354`	`::Unserialize(s, VARINT(nHeight));`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ class TxInUndoDeserializer`
`54`	`54`	`int nVersionDummy;`
`55`	`55`	`::Unserialize(s, VARINT(nVersionDummy));`
`56`	`56`	`}`
`57`		`- ::Unserialize(s, REF(CTxOutCompressor(REF(txout->out))));`
	`57`	`+ ::Unserialize(s, CTxOutCompressor(REF(txout->out)));`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`explicit TxInUndoDeserializer(Coin* coin) : txout(coin) {}`
`@@ -76,7 +76,7 @@ class CTxUndo`
`76`	`76`	`uint64_t count = vprevout.size();`
`77`	`77`	`::Serialize(s, COMPACTSIZE(REF(count)));`
`78`	`78`	`for (const auto& prevout : vprevout) {`
`79`		`- ::Serialize(s, REF(TxInUndoSerializer(&prevout)));`
	`79`	`+ ::Serialize(s, TxInUndoSerializer(&prevout));`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`@@ -90,7 +90,7 @@ class CTxUndo`
`90`	`90`	`}`
`91`	`91`	`vprevout.resize(count);`
`92`	`92`	`for (auto& prevout : vprevout) {`
`93`		`- ::Unserialize(s, REF(TxInUndoDeserializer(&prevout)));`
	`93`	`+ ::Unserialize(s, TxInUndoDeserializer(&prevout));`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`};`