diff --git a/src/blockencodings.h b/src/blockencodings.h
index 4a20d10a8..0babb47f3 100644
--- a/src/blockencodings.h
+++ b/src/blockencodings.h
@@ -1,239 +1,239 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_BLOCK_ENCODINGS_H
 #define BITCOIN_BLOCK_ENCODINGS_H
 
 #include <primitives/block.h>
 
 #include <memory>
 
 class Config;
 class CTxMemPool;
 
 // Dumb helper to handle CTransaction compression at serialize-time
 struct TransactionCompressor {
 private:
     CTransactionRef &tx;
 
 public:
     explicit TransactionCompressor(CTransactionRef &txIn) : tx(txIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         // TODO: Compress tx encoding
         READWRITE(tx);
     }
 };
 
 class BlockTransactionsRequest {
 public:
     // A BlockTransactionsRequest message
     uint256 blockhash;
     std::vector<uint32_t> indices;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(blockhash);
         uint64_t indices_size = uint64_t(indices.size());
         READWRITE(COMPACTSIZE(indices_size));
         if (ser_action.ForRead()) {
             size_t i = 0;
             while (indices.size() < indices_size) {
                 indices.resize(
                     std::min(uint64_t(1000 + indices.size()), indices_size));
                 for (; i < indices.size(); i++) {
                     uint64_t n = 0;
                     READWRITE(COMPACTSIZE(n));
                     if (n > std::numeric_limits<uint32_t>::max()) {
                         throw std::ios_base::failure(
                             "index overflowed 32 bits");
                     }
                     indices[i] = n;
                 }
             }
 
             uint32_t offset = 0;
             for (auto &index : indices) {
                 if (uint64_t(index) + uint64_t(offset) >
                     std::numeric_limits<uint32_t>::max()) {
                     throw std::ios_base::failure("indices overflowed 32 bits");
                 }
                 index = index + offset;
                 offset = index + 1;
             }
         } else {
             for (size_t i = 0; i < indices.size(); i++) {
                 uint64_t index =
                     indices[i] - (i == 0 ? 0 : (indices[i - 1] + 1));
                 READWRITE(COMPACTSIZE(index));
             }
         }
     }
 };
 
 class BlockTransactions {
 public:
     // A BlockTransactions message
     uint256 blockhash;
     std::vector<CTransactionRef> txn;
 
     BlockTransactions() {}
     explicit BlockTransactions(const BlockTransactionsRequest &req)
         : blockhash(req.blockhash), txn(req.indices.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])));
+                    READWRITE(TransactionCompressor(txn[i]));
                 }
             }
         } else {
             for (size_t i = 0; i < txn.size(); i++) {
-                READWRITE(REF(TransactionCompressor(txn[i])));
+                READWRITE(TransactionCompressor(txn[i]));
             }
         }
     }
 };
 
 // Dumb serialization/storage-helper for CBlockHeaderAndShortTxIDs and
 // PartiallyDownloadedBlock
 struct PrefilledTransaction {
     // Used as an offset since last prefilled tx in CBlockHeaderAndShortTxIDs,
     // as a proper transaction-in-block-index in PartiallyDownloadedBlock
     uint32_t index;
     CTransactionRef tx;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         uint64_t n = index;
         READWRITE(COMPACTSIZE(n));
         if (n > std::numeric_limits<uint32_t>::max()) {
             throw std::ios_base::failure("index overflowed 32-bits");
         }
         index = n;
-        READWRITE(REF(TransactionCompressor(tx)));
+        READWRITE(TransactionCompressor(tx));
     }
 };
 
 typedef enum ReadStatus_t {
     READ_STATUS_OK,
     // Invalid object, peer is sending bogus crap.
     // FIXME: differenciate bogus crap from crap that do not fit our policy.
     READ_STATUS_INVALID,
     // Failed to process object.
     READ_STATUS_FAILED,
     // Used only by FillBlock to indicate a failure in CheckBlock.
     READ_STATUS_CHECKBLOCK_FAILED,
 } ReadStatus;
 
 class CBlockHeaderAndShortTxIDs {
 private:
     mutable uint64_t shorttxidk0, shorttxidk1;
     uint64_t nonce;
 
     void FillShortTxIDSelector() const;
 
     friend class PartiallyDownloadedBlock;
 
     static const int SHORTTXIDS_LENGTH = 6;
 
 protected:
     std::vector<uint64_t> shorttxids;
     std::vector<PrefilledTransaction> prefilledtxn;
 
 public:
     CBlockHeader header;
 
     // Dummy for deserialization
     CBlockHeaderAndShortTxIDs() {}
 
     CBlockHeaderAndShortTxIDs(const CBlock &block);
 
     uint64_t GetShortID(const uint256 &txhash) const;
 
     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 (uint64_t shortid : shorttxids) {
                 uint32_t lsb = shortid & 0xffffffff;
                 uint16_t msb = (shortid >> 32) & 0xffff;
                 READWRITE(lsb);
                 READWRITE(msb);
             }
         }
 
         READWRITE(prefilledtxn);
 
         if (ser_action.ForRead()) {
             FillShortTxIDSelector();
         }
     }
 };
 
 class PartiallyDownloadedBlock {
 protected:
     std::vector<CTransactionRef> txns_available;
     size_t prefilled_count = 0, mempool_count = 0, extra_count = 0;
     CTxMemPool *pool;
     const Config *config;
 
 public:
     CBlockHeader header;
     PartiallyDownloadedBlock(const Config &configIn, CTxMemPool *poolIn)
         : pool(poolIn), config(&configIn) {}
 
     // extra_txn is a list of extra transactions to look at, in <txhash,
     // reference> form.
     ReadStatus
     InitData(const CBlockHeaderAndShortTxIDs &cmpctblock,
              const std::vector<std::pair<uint256, CTransactionRef>> &extra_txn);
     bool IsTxAvailable(size_t index) const;
     ReadStatus FillBlock(CBlock &block,
                          const std::vector<CTransactionRef> &vtx_missing);
 };
 
 #endif
diff --git a/src/coins.h b/src/coins.h
index 7c0c47733..5273263c0 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -1,316 +1,316 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_COINS_H
 #define BITCOIN_COINS_H
 
 #include <compressor.h>
 #include <core_memusage.h>
 #include <crypto/siphash.h>
 #include <memusage.h>
 #include <serialize.h>
 #include <uint256.h>
 
 #include <cassert>
 #include <cstdint>
 #include <unordered_map>
 
 /**
  * A UTXO entry.
  *
  * Serialized format:
  * - VARINT((coinbase ? 1 : 0) | (height << 1))
  * - the non-spent CTxOut (via CTxOutCompressor)
  */
 class Coin {
     //! Unspent transaction output.
     CTxOut out;
 
     //! Whether containing transaction was a coinbase and height at which the
     //! transaction was included into a block.
     uint32_t nHeightAndIsCoinBase;
 
 public:
     //! Empty constructor
     Coin() : nHeightAndIsCoinBase(0) {}
 
     //! Constructor from a CTxOut and height/coinbase information.
     Coin(CTxOut outIn, uint32_t nHeightIn, bool IsCoinbase)
         : out(std::move(outIn)),
           nHeightAndIsCoinBase((nHeightIn << 1) | IsCoinbase) {}
 
     uint32_t GetHeight() const { return nHeightAndIsCoinBase >> 1; }
     bool IsCoinBase() const { return nHeightAndIsCoinBase & 0x01; }
     bool IsSpent() const { return out.IsNull(); }
 
     CTxOut &GetTxOut() { return out; }
     const CTxOut &GetTxOut() const { return out; }
 
     void Clear() {
         out.SetNull();
         nHeightAndIsCoinBase = 0;
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         assert(!IsSpent());
         ::Serialize(s, VARINT(nHeightAndIsCoinBase));
         ::Serialize(s, CTxOutCompressor(REF(out)));
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         ::Unserialize(s, VARINT(nHeightAndIsCoinBase));
-        ::Unserialize(s, REF(CTxOutCompressor(out)));
+        ::Unserialize(s, CTxOutCompressor(out));
     }
 
     size_t DynamicMemoryUsage() const {
         return memusage::DynamicUsage(out.scriptPubKey);
     }
 };
 
 class SaltedOutpointHasher {
 private:
     /** Salt */
     const uint64_t k0, k1;
 
 public:
     SaltedOutpointHasher();
 
     /**
      * This *must* return size_t. With Boost 1.46 on 32-bit systems the
      * unordered_map will behave unpredictably if the custom hasher returns a
      * uint64_t, resulting in failures when syncing the chain (#4634).
      * Note: This information above might be outdated as the unordered map
      * container type has meanwhile been switched to the C++ standard library
      * implementation.
      */
     size_t operator()(const COutPoint &outpoint) const {
         return SipHashUint256Extra(k0, k1, outpoint.GetTxId(), outpoint.GetN());
     }
 };
 
 struct CCoinsCacheEntry {
     // The actual cached data.
     Coin coin;
     uint8_t flags;
 
     enum Flags {
         // This cache entry is potentially different from the version in the
         // parent view.
         DIRTY = (1 << 0),
         // The parent view does not have this entry (or it is pruned).
         FRESH = (1 << 1),
         /* Note that FRESH is a performance optimization with which we can erase
            coins that are fully spent if we know we do not need to flush the
            changes to the parent cache. It is always safe to not mark FRESH if
            that condition is not guaranteed. */
     };
 
     CCoinsCacheEntry() : flags(0) {}
     explicit CCoinsCacheEntry(Coin coinIn)
         : coin(std::move(coinIn)), flags(0) {}
 };
 
 typedef std::unordered_map<COutPoint, CCoinsCacheEntry, SaltedOutpointHasher>
     CCoinsMap;
 
 /** Cursor for iterating over CoinsView state */
 class CCoinsViewCursor {
 public:
     CCoinsViewCursor(const uint256 &hashBlockIn) : hashBlock(hashBlockIn) {}
     virtual ~CCoinsViewCursor() {}
 
     virtual bool GetKey(COutPoint &key) const = 0;
     virtual bool GetValue(Coin &coin) const = 0;
     virtual unsigned int GetValueSize() const = 0;
 
     virtual bool Valid() const = 0;
     virtual void Next() = 0;
 
     //! Get best block at the time this cursor was created
     const uint256 &GetBestBlock() const { return hashBlock; }
 
 private:
     uint256 hashBlock;
 };
 
 /** Abstract view on the open txout dataset. */
 class CCoinsView {
 public:
     //! Retrieve the Coin (unspent transaction output) for a given outpoint.
     virtual bool GetCoin(const COutPoint &outpoint, Coin &coin) const;
 
     //! Just check whether we have data for a given outpoint.
     //! This may (but cannot always) return true for spent outputs.
     virtual bool HaveCoin(const COutPoint &outpoint) const;
 
     //! Retrieve the block hash whose state this CCoinsView currently represents
     virtual uint256 GetBestBlock() const;
 
     //! Retrieve the range of blocks that may have been only partially written.
     //! If the database is in a consistent state, the result is the empty
     //! vector.
     //! Otherwise, a two-element vector is returned consisting of the new and
     //! the old block hash, in that order.
     virtual std::vector<uint256> GetHeadBlocks() const;
 
     //! Do a bulk modification (multiple Coin changes + BestBlock change).
     //! The passed mapCoins can be modified.
     virtual bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock);
 
     //! Get a cursor to iterate over the whole state
     virtual CCoinsViewCursor *Cursor() const;
 
     //! As we use CCoinsViews polymorphically, have a virtual destructor
     virtual ~CCoinsView() {}
 
     //! Estimate database size (0 if not implemented)
     virtual size_t EstimateSize() const { return 0; }
 };
 
 /** CCoinsView backed by another CCoinsView */
 class CCoinsViewBacked : public CCoinsView {
 protected:
     CCoinsView *base;
 
 public:
     CCoinsViewBacked(CCoinsView *viewIn);
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
     uint256 GetBestBlock() const override;
     std::vector<uint256> GetHeadBlocks() const override;
     void SetBackend(CCoinsView &viewIn);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) override;
     CCoinsViewCursor *Cursor() const override;
     size_t EstimateSize() const override;
 };
 
 /**
  * CCoinsView that adds a memory cache for transactions to another CCoinsView
  */
 class CCoinsViewCache : public CCoinsViewBacked {
 protected:
     /**
      * Make mutable so that we can "fill the cache" even from Get-methods
      * declared as "const".
      */
     mutable uint256 hashBlock;
     mutable CCoinsMap cacheCoins;
 
     /* Cached dynamic memory usage for the inner Coin objects. */
     mutable size_t cachedCoinsUsage;
 
 public:
     CCoinsViewCache(CCoinsView *baseIn);
 
     // Standard CCoinsView methods
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
     uint256 GetBestBlock() const override;
     void SetBestBlock(const uint256 &hashBlock);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) override;
     CCoinsViewCursor *Cursor() const override {
         throw std::logic_error(
             "CCoinsViewCache cursor iteration not supported.");
     }
 
     /**
      * Check if we have the given utxo already loaded in this cache.
      * The semantics are the same as HaveCoin(), but no calls to the backing
      * CCoinsView are made.
      */
     bool HaveCoinInCache(const COutPoint &outpoint) const;
 
     /**
      * Return a reference to a Coin in the cache, or a pruned one if not found.
      * This is more efficient than GetCoin. Modifications to other cache entries
      * are allowed while accessing the returned pointer.
      */
     const Coin &AccessCoin(const COutPoint &output) const;
 
     /**
      * Add a coin. Set potential_overwrite to true if a non-pruned version may
      * already exist.
      */
     void AddCoin(const COutPoint &outpoint, Coin coin,
                  bool potential_overwrite);
 
     /**
      * Spend a coin. Pass moveto in order to get the deleted data.
      * If no unspent output exists for the passed outpoint, this call has no
      * effect.
      */
     bool SpendCoin(const COutPoint &outpoint, Coin *moveto = nullptr);
 
     /**
      * Push the modifications applied to this cache to its base.
      * Failure to call this method before destruction will cause the changes to
      * be forgotten. If false is returned, the state of this cache (and its
      * backing view) will be undefined.
      */
     bool Flush();
 
     /**
      * Removes the UTXO with the given outpoint from the cache, if it is not
      * modified.
      */
     void Uncache(const COutPoint &outpoint);
 
     //! Calculate the size of the cache (in number of transaction outputs)
     unsigned int GetCacheSize() const;
 
     //! Calculate the size of the cache (in bytes)
     size_t DynamicMemoryUsage() const;
 
     /**
      * Amount of bitcoins coming in to a transaction
      * Note that lightweight clients may not know anything besides the hash of
      * previous transactions, so may not be able to calculate this.
      *
      * @param[in] tx	transaction for which we are checking input total
      * @return	Sum of value of all inputs (scriptSigs)
      */
     Amount GetValueIn(const CTransaction &tx) const;
 
     //! Check whether all prevouts of the transaction are present in the UTXO
     //! set represented by this view
     bool HaveInputs(const CTransaction &tx) const;
 
     /**
      * Return priority of tx at height nHeight. Also calculate the sum of the
      * values of the inputs that are already in the chain. These are the inputs
      * that will age and increase priority as new blocks are added to the chain.
      */
     double GetPriority(const CTransaction &tx, int nHeight,
                        Amount &inChainInputValue) const;
 
     const CTxOut &GetOutputFor(const CTxIn &input) const;
 
 private:
     CCoinsMap::iterator FetchCoin(const COutPoint &outpoint) const;
 
     /**
      * By making the copy constructor private, we prevent accidentally using it
      * when one intends to create a cache on top of a base cache.
      */
     CCoinsViewCache(const CCoinsViewCache &);
 };
 
 //! Utility function to add all of a transaction's outputs to a cache.
 // When check is false, this assumes that overwrites are only possible for
 // coinbase transactions.
 // When check is true, the underlying view may be queried to determine whether
 // an addition is an overwrite.
 // TODO: pass in a boolean to limit these possible overwrites to known
 // (pre-BIP34) cases.
 void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight,
               bool check = false);
 
 //! Utility function to find any unspent output with a given txid.
 // This function can be quite expensive because in the event of a transaction
 // which is not found in the cache, it can cause up to MAX_OUTPUTS_PER_BLOCK
 // lookups to database, so it should be used with care.
 const Coin &AccessByTxid(const CCoinsViewCache &cache, const TxId &txid);
 
 #endif // BITCOIN_COINS_H
diff --git a/src/compressor.h b/src/compressor.h
index aa1d367e0..286c2eb41 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -1,120 +1,120 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_COMPRESSOR_H
 #define BITCOIN_COMPRESSOR_H
 
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <serialize.h>
 
 class CKeyID;
 class CPubKey;
 class CScriptID;
 
 /**
  * Compact serializer for scripts.
  *
  * It detects common cases and encodes them much more efficiently.
  * 3 special cases are defined:
  *  * Pay to pubkey hash (encoded as 21 bytes)
  *  * Pay to script hash (encoded as 21 bytes)
  *  * Pay to pubkey starting with 0x02, 0x03 or 0x04 (encoded as 33 bytes)
  *
  * 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 {
 private:
     /**
      * make this static for now (there are only 6 special scripts defined) this
      * can potentially be extended together with a new nVersion for
      * transactions, in which case this value becomes dependent on nVersion and
      * nHeight of the enclosing transaction.
      */
     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<uint8_t> &out) const;
     unsigned int GetSpecialSize(unsigned int nSize) const;
     bool Decompress(unsigned int nSize, const std::vector<uint8_t> &out);
 
 public:
     explicit CScriptCompressor(CScript &scriptIn) : script(scriptIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         std::vector<uint8_t> compr;
         if (Compress(compr)) {
             s << CFlatData(compr);
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
         s << CFlatData(script);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int nSize = 0;
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             std::vector<uint8_t> vch(GetSpecialSize(nSize), 0x00);
-            s >> REF(CFlatData(vch));
+            s >> CFlatData(vch);
             Decompress(nSize, vch);
             return;
         }
         nSize -= nSpecialScripts;
         if (nSize > MAX_SCRIPT_SIZE) {
             // Overly long script, replace with a short invalid one
             script << OP_RETURN;
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> REF(CFlatData(script));
+            s >> CFlatData(script);
         }
     }
 };
 
 /** wrapper for CTxOut that provides a more compact serialization */
 class CTxOutCompressor {
 private:
     CTxOut &txout;
 
 public:
     static uint64_t CompressAmount(Amount nAmount);
     static Amount DecompressAmount(uint64_t nAmount);
 
     explicit CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     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);
     }
 };
 
 #endif // BITCOIN_COMPRESSOR_H
diff --git a/src/hash.h b/src/hash.h
index 93234aa3b..044c80f41 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -1,216 +1,216 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_HASH_H
 #define BITCOIN_HASH_H
 
 #include <crypto/ripemd160.h>
 #include <crypto/sha256.h>
 #include <prevector.h>
 #include <serialize.h>
 #include <uint256.h>
 #include <version.h>
 
 #include <vector>
 
 typedef uint256 ChainCode;
 
 /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
 class CHash256 {
 private:
     CSHA256 sha;
 
 public:
     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
 
     void Finalize(uint8_t hash[OUTPUT_SIZE]) {
         uint8_t buf[CSHA256::OUTPUT_SIZE];
         sha.Finalize(buf);
         sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
     }
 
     CHash256 &Write(const uint8_t *data, size_t len) {
         sha.Write(data, len);
         return *this;
     }
 
     CHash256 &Reset() {
         sha.Reset();
         return *this;
     }
 };
 
 /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
 class CHash160 {
 private:
     CSHA256 sha;
 
 public:
     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
 
     void Finalize(uint8_t hash[OUTPUT_SIZE]) {
         uint8_t buf[CSHA256::OUTPUT_SIZE];
         sha.Finalize(buf);
         CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
     }
 
     CHash160 &Write(const uint8_t *data, size_t len) {
         sha.Write(data, len);
         return *this;
     }
 
     CHash160 &Reset() {
         sha.Reset();
         return *this;
     }
 };
 
 /** Compute the 256-bit hash of an object. */
 template <typename T1> inline uint256 Hash(const T1 pbegin, const T1 pend) {
     static const uint8_t pblank[1] = {};
     uint256 result;
     CHash256()
         .Write(pbegin == pend ? pblank : (const uint8_t *)&pbegin[0],
                (pend - pbegin) * sizeof(pbegin[0]))
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 256-bit hash of the concatenation of two objects. */
 template <typename T1, typename T2>
 inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin,
                     const T2 p2end) {
     static const uint8_t pblank[1] = {};
     uint256 result;
     CHash256()
         .Write(p1begin == p1end ? pblank : (const uint8_t *)&p1begin[0],
                (p1end - p1begin) * sizeof(p1begin[0]))
         .Write(p2begin == p2end ? pblank : (const uint8_t *)&p2begin[0],
                (p2end - p2begin) * sizeof(p2begin[0]))
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 256-bit hash of the concatenation of three objects. */
 template <typename T1, typename T2, typename T3>
 inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin,
                     const T2 p2end, const T3 p3begin, const T3 p3end) {
     static const uint8_t pblank[1] = {};
     uint256 result;
     CHash256()
         .Write(p1begin == p1end ? pblank : (const uint8_t *)&p1begin[0],
                (p1end - p1begin) * sizeof(p1begin[0]))
         .Write(p2begin == p2end ? pblank : (const uint8_t *)&p2begin[0],
                (p2end - p2begin) * sizeof(p2begin[0]))
         .Write(p3begin == p3end ? pblank : (const uint8_t *)&p3begin[0],
                (p3end - p3begin) * sizeof(p3begin[0]))
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 160-bit hash an object. */
 template <typename T1> inline uint160 Hash160(const T1 pbegin, const T1 pend) {
     static uint8_t pblank[1] = {};
     uint160 result;
     CHash160()
         .Write(pbegin == pend ? pblank : (const uint8_t *)&pbegin[0],
                (pend - pbegin) * sizeof(pbegin[0]))
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 160-bit hash of a vector. */
 inline uint160 Hash160(const std::vector<uint8_t> &vch) {
     return Hash160(vch.begin(), vch.end());
 }
 
 /** Compute the 160-bit hash of a vector. */
 template <unsigned int N>
 inline uint160 Hash160(const prevector<N, uint8_t> &vch) {
     return Hash160(vch.begin(), vch.end());
 }
 
 /** A writer stream (for serialization) that computes a 256-bit hash. */
 class CHashWriter {
 private:
     CHash256 ctx;
 
     const int nType;
     const int nVersion;
 
 public:
     CHashWriter(int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn) {}
 
     int GetType() const { return nType; }
     int GetVersion() const { return nVersion; }
 
     void write(const char *pch, size_t size) {
         ctx.Write((const uint8_t *)pch, size);
     }
 
     // invalidates the object
     uint256 GetHash() {
         uint256 result;
         ctx.Finalize((uint8_t *)&result);
         return result;
     }
 
     template <typename T> CHashWriter &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 };
 
 /**
  * Reads data from an underlying stream, while hashing the read data.
  */
 template <typename Source> class CHashVerifier : public CHashWriter {
 private:
     Source *source;
 
 public:
     explicit CHashVerifier(Source *source_)
         : CHashWriter(source_->GetType(), source_->GetVersion()),
           source(source_) {}
 
     void read(char *pch, size_t nSize) {
         source->read(pch, nSize);
         this->write(pch, nSize);
     }
 
     void ignore(size_t nSize) {
         char data[1024];
         while (nSize > 0) {
             size_t now = std::min<size_t>(nSize, 1024);
             read(data, now);
             nSize -= now;
         }
     }
 
-    template <typename T> CHashVerifier<Source> &operator>>(T &obj) {
+    template <typename T> CHashVerifier<Source> &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 };
 
 /** Compute the 256-bit hash of an object's serialization. */
 template <typename T>
 uint256 SerializeHash(const T &obj, int nType = SER_GETHASH,
                       int nVersion = PROTOCOL_VERSION) {
     CHashWriter ss(nType, nVersion);
     ss << obj;
     return ss.GetHash();
 }
 
 uint32_t MurmurHash3(uint32_t nHashSeed,
                      const std::vector<uint8_t> &vDataToHash);
 
 void BIP32Hash(const ChainCode &chainCode, uint32_t nChild, uint8_t header,
                const uint8_t data[32], uint8_t output[64]);
 
 #endif // BITCOIN_HASH_H
diff --git a/src/script/bitcoinconsensus.cpp b/src/script/bitcoinconsensus.cpp
index bc4647e73..7b4ef6135 100644
--- a/src/script/bitcoinconsensus.cpp
+++ b/src/script/bitcoinconsensus.cpp
@@ -1,139 +1,139 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/bitcoinconsensus.h>
 
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <version.h>
 
 namespace {
 
 /** A class that deserializes a single CTransaction one time. */
 class TxInputStream {
 public:
     TxInputStream(int nTypeIn, int nVersionIn, const uint8_t *txTo,
                   size_t txToLen)
         : m_type(nTypeIn), m_version(nVersionIn), m_data(txTo),
           m_remaining(txToLen) {}
 
     void read(char *pch, size_t nSize) {
         if (nSize > m_remaining) {
             throw std::ios_base::failure(std::string(__func__) +
                                          ": end of data");
         }
 
         if (pch == nullptr) {
             throw std::ios_base::failure(std::string(__func__) +
                                          ": bad destination buffer");
         }
 
         if (m_data == nullptr) {
             throw std::ios_base::failure(std::string(__func__) +
                                          ": bad source buffer");
         }
 
         memcpy(pch, m_data, nSize);
         m_remaining -= nSize;
         m_data += nSize;
     }
 
-    template <typename T> TxInputStream &operator>>(T &obj) {
+    template <typename T> TxInputStream &operator>>(T &&obj) {
         ::Unserialize(*this, obj);
         return *this;
     }
 
     int GetVersion() const { return m_version; }
     int GetType() const { return m_type; }
 
 private:
     const int m_type;
     const int m_version;
     const uint8_t *m_data;
     size_t m_remaining;
 };
 
 inline int set_error(bitcoinconsensus_error *ret,
                      bitcoinconsensus_error serror) {
     if (ret) {
         *ret = serror;
     }
 
     return 0;
 }
 
 struct ECCryptoClosure {
     ECCVerifyHandle handle;
 };
 
 ECCryptoClosure instance_of_eccryptoclosure;
 } // namespace
 
 /** Check that all specified flags are part of the libconsensus interface. */
 static bool verify_flags(unsigned int flags) {
     return (flags & ~(bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL)) == 0;
 }
 
 static int verify_script(const uint8_t *scriptPubKey,
                          unsigned int scriptPubKeyLen, Amount amount,
                          const uint8_t *txTo, unsigned int txToLen,
                          unsigned int nIn, unsigned int flags,
                          bitcoinconsensus_error *err) {
     if (!verify_flags(flags)) {
         return bitcoinconsensus_ERR_INVALID_FLAGS;
     }
     try {
         TxInputStream stream(SER_NETWORK, PROTOCOL_VERSION, txTo, txToLen);
         CTransaction tx(deserialize, stream);
         if (nIn >= tx.vin.size()) {
             return set_error(err, bitcoinconsensus_ERR_TX_INDEX);
         }
 
         if (GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) != txToLen) {
             return set_error(err, bitcoinconsensus_ERR_TX_SIZE_MISMATCH);
         }
 
         // Regardless of the verification result, the tx did not error.
         set_error(err, bitcoinconsensus_ERR_OK);
 
         PrecomputedTransactionData txdata(tx);
         return VerifyScript(
             tx.vin[nIn].scriptSig,
             CScript(scriptPubKey, scriptPubKey + scriptPubKeyLen), flags,
             TransactionSignatureChecker(&tx, nIn, amount, txdata), nullptr);
     } catch (const std::exception &) {
         // Error deserializing
         return set_error(err, bitcoinconsensus_ERR_TX_DESERIALIZE);
     }
 }
 
 int bitcoinconsensus_verify_script_with_amount(
     const uint8_t *scriptPubKey, unsigned int scriptPubKeyLen, int64_t amount,
     const uint8_t *txTo, unsigned int txToLen, unsigned int nIn,
     unsigned int flags, bitcoinconsensus_error *err) {
     Amount am(amount * SATOSHI);
     return ::verify_script(scriptPubKey, scriptPubKeyLen, am, txTo, txToLen,
                            nIn, flags, err);
 }
 
 int bitcoinconsensus_verify_script(const uint8_t *scriptPubKey,
                                    unsigned int scriptPubKeyLen,
                                    const uint8_t *txTo, unsigned int txToLen,
                                    unsigned int nIn, unsigned int flags,
                                    bitcoinconsensus_error *err) {
     if (flags & bitcoinconsensus_SCRIPT_ENABLE_SIGHASH_FORKID ||
         flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS_DEPRECATED) {
         return set_error(err, bitcoinconsensus_ERR_AMOUNT_REQUIRED);
     }
 
     return ::verify_script(scriptPubKey, scriptPubKeyLen, Amount::zero(), txTo,
                            txToLen, nIn, flags, err);
 }
 
 unsigned int bitcoinconsensus_version() {
     // Just use the API version for now
     return BITCOINCONSENSUS_API_VER;
 }
diff --git a/src/serialize.h b/src/serialize.h
index c729219a8..9665a87cf 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -1,912 +1,911 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SERIALIZE_H
 #define BITCOIN_SERIALIZE_H
 
 #include <compat/endian.h>
 #include <prevector.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <ios>
 #include <limits>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 static const uint64_t MAX_SIZE = 0x02000000;
 
 /**
  * Dummy data type to identify deserializing constructors.
  *
  * By convention, a constructor of a type T with signature
  *
  *   template <typename Stream> T::T(deserialize_type, Stream& s)
  *
  * is a deserializing constructor, which builds the type by deserializing it
  * from s. If T contains const fields, this is likely the only way to do so.
  */
 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
  */
 template <typename Stream> inline void ser_writedata8(Stream &s, uint8_t obj) {
     s.write((char *)&obj, 1);
 }
 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_writedata32(Stream &s, uint32_t obj) {
     obj = htole32(obj);
     s.write((char *)&obj, 4);
 }
 template <typename Stream>
 inline void ser_writedata32be(Stream &s, uint32_t obj) {
     obj = htobe32(obj);
     s.write((char *)&obj, 4);
 }
 template <typename Stream>
 inline void ser_writedata64(Stream &s, uint64_t obj) {
     obj = htole64(obj);
     s.write((char *)&obj, 8);
 }
 template <typename Stream> inline uint8_t ser_readdata8(Stream &s) {
     uint8_t obj;
     s.read((char *)&obj, 1);
     return obj;
 }
 template <typename Stream> inline uint16_t ser_readdata16(Stream &s) {
     uint16_t obj;
     s.read((char *)&obj, 2);
     return le16toh(obj);
 }
 template <typename Stream> inline uint32_t ser_readdata32(Stream &s) {
     uint32_t obj;
     s.read((char *)&obj, 4);
     return le32toh(obj);
 }
 template <typename Stream> inline uint32_t ser_readdata32be(Stream &s) {
     uint32_t obj;
     s.read((char *)&obj, 4);
     return be32toh(obj);
 }
 template <typename Stream> inline uint64_t ser_readdata64(Stream &s) {
     uint64_t obj;
     s.read((char *)&obj, 8);
     return le64toh(obj);
 }
 inline uint64_t ser_double_to_uint64(double x) {
     union {
         double x;
         uint64_t y;
     } tmp;
     tmp.x = x;
     return tmp.y;
 }
 inline uint32_t ser_float_to_uint32(float x) {
     union {
         float x;
         uint32_t y;
     } tmp;
     tmp.x = x;
     return tmp.y;
 }
 inline double ser_uint64_to_double(uint64_t y) {
     union {
         double x;
         uint64_t y;
     } tmp;
     tmp.y = y;
     return tmp.x;
 }
 inline float ser_uint32_to_float(uint32_t y) {
     union {
         float x;
         uint32_t y;
     } tmp;
     tmp.y = y;
     return tmp.x;
 }
 
 /////////////////////////////////////////////////////////////////
 //
 // Templates for serializing to anything that looks like a stream,
 // i.e. anything that supports .read(char*, size_t) and .write(char*, size_t)
 //
 class CSizeComputer;
 
 enum {
     // primary actions
     SER_NETWORK = (1 << 0),
     SER_DISK = (1 << 1),
     SER_GETHASH = (1 << 2),
 };
 
 #define READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
 
 /**
  * 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());                           \
     }
 
 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);
 }
 template <typename Stream> inline void Serialize(Stream &s, int16_t a) {
     ser_writedata16(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint16_t a) {
     ser_writedata16(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, int32_t a) {
     ser_writedata32(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint32_t a) {
     ser_writedata32(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, int64_t a) {
     ser_writedata64(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint64_t a) {
     ser_writedata64(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, float a) {
     ser_writedata32(s, ser_float_to_uint32(a));
 }
 template <typename Stream> inline void Serialize(Stream &s, double a) {
     ser_writedata64(s, ser_double_to_uint64(a));
 }
 // TODO Get rid of bare char
 template <typename Stream> inline void Unserialize(Stream &s, char &a) {
     a = ser_readdata8(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int8_t &a) {
     a = ser_readdata8(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint8_t &a) {
     a = ser_readdata8(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int16_t &a) {
     a = ser_readdata16(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint16_t &a) {
     a = ser_readdata16(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int32_t &a) {
     a = ser_readdata32(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint32_t &a) {
     a = ser_readdata32(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int64_t &a) {
     a = ser_readdata64(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint64_t &a) {
     a = ser_readdata64(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, float &a) {
     a = ser_uint32_to_float(ser_readdata32(s));
 }
 template <typename Stream> inline void Unserialize(Stream &s, double &a) {
     a = ser_uint64_to_double(ser_readdata64(s));
 }
 
 template <typename Stream> inline void Serialize(Stream &s, bool a) {
     char f = a;
     ser_writedata8(s, f);
 }
 template <typename Stream> inline void Unserialize(Stream &s, bool &a) {
     char f = ser_readdata8(s);
     a = f;
 }
 
 /**
  * Compact Size
  * size <  253        -- 1 byte
  * size <= USHRT_MAX  -- 3 bytes  (253 + 2 bytes)
  * size <= UINT_MAX   -- 5 bytes  (254 + 4 bytes)
  * size >  UINT_MAX   -- 9 bytes  (255 + 8 bytes)
  */
 inline uint32_t GetSizeOfCompactSize(uint64_t nSize) {
     if (nSize < 253) {
         return sizeof(uint8_t);
     }
     if (nSize <= std::numeric_limits<uint16_t>::max()) {
         return sizeof(uint8_t) + sizeof(uint16_t);
     }
     if (nSize <= std::numeric_limits<uint32_t>::max()) {
         return sizeof(uint8_t) + sizeof(uint32_t);
     }
 
     return sizeof(uint8_t) + sizeof(uint64_t);
 }
 
 inline void WriteCompactSize(CSizeComputer &os, uint64_t nSize);
 
 template <typename Stream> void WriteCompactSize(Stream &os, uint64_t nSize) {
     if (nSize < 253) {
         ser_writedata8(os, nSize);
     } else if (nSize <= std::numeric_limits<uint16_t>::max()) {
         ser_writedata8(os, 253);
         ser_writedata16(os, nSize);
     } else if (nSize <= std::numeric_limits<uint32_t>::max()) {
         ser_writedata8(os, 254);
         ser_writedata32(os, nSize);
     } else {
         ser_writedata8(os, 255);
         ser_writedata64(os, nSize);
     }
     return;
 }
 
 template <typename Stream> uint64_t ReadCompactSize(Stream &is) {
     uint8_t chSize = ser_readdata8(is);
     uint64_t nSizeRet = 0;
     if (chSize < 253) {
         nSizeRet = chSize;
     } else if (chSize == 253) {
         nSizeRet = ser_readdata16(is);
         if (nSizeRet < 253) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
         }
     } else if (chSize == 254) {
         nSizeRet = ser_readdata32(is);
         if (nSizeRet < 0x10000u) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
         }
     } else {
         nSizeRet = ser_readdata64(is);
         if (nSizeRet < 0x100000000ULL) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
         }
     }
     if (nSizeRet > MAX_SIZE) {
         throw std::ios_base::failure("ReadCompactSize(): size too large");
     }
     return nSizeRet;
 }
 
 /**
  * Variable-length integers: bytes are a MSB base-128 encoding of the number.
  * The high bit in each byte signifies whether another digit follows. To make
  * sure the encoding is one-to-one, one is subtracted from all but the last
  * digit. Thus, the byte sequence a[] with length len, where all but the last
  * byte has bit 128 set, encodes the number:
  *
  *  (a[len-1] & 0x7F) + sum(i=1..len-1, 128^i*((a[len-i-1] & 0x7F)+1))
  *
  * Properties:
  * * Very small (0-127: 1 byte, 128-16511: 2 bytes, 16512-2113663: 3 bytes)
  * * Every integer has exactly one encoding
  * * Encoding does not depend on size of original integer type
  * * No redundancy: every (infinite) byte sequence corresponds to a list
  *   of encoded integers.
  *
  * 0:         [0x00]  256:        [0x81 0x00]
  * 1:         [0x01]  16383:      [0xFE 0x7F]
  * 127:       [0x7F]  16384:      [0xFF 0x00]
  * 128:  [0x80 0x00]  16511:      [0xFF 0x7F]
  * 255:  [0x80 0x7F]  65535: [0x82 0xFE 0x7F]
  * 2^32:           [0x8E 0xFE 0xFE 0xFF 0x00]
  */
 template <typename I> inline unsigned int GetSizeOfVarInt(I n) {
     int nRet = 0;
     while (true) {
         nRet++;
         if (n <= 0x7F) {
             return nRet;
         }
         n = (n >> 7) - 1;
     }
 }
 
 template <typename I> inline void WriteVarInt(CSizeComputer &os, I n);
 
 template <typename Stream, typename I> void WriteVarInt(Stream &os, I n) {
     uint8_t tmp[(sizeof(n) * 8 + 6) / 7];
     int len = 0;
     while (true) {
         tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
         if (n <= 0x7F) {
             break;
         }
         n = (n >> 7) - 1;
         len++;
     }
     do {
         ser_writedata8(os, tmp[len]);
     } while (len--);
 }
 
 template <typename Stream, typename I> I ReadVarInt(Stream &is) {
     I n = 0;
     while (true) {
         uint8_t chData = ser_readdata8(is);
         if (n > (std::numeric_limits<I>::max() >> 7)) {
             throw std::ios_base::failure("ReadVarInt(): size too large");
         }
         n = (n << 7) | (chData & 0x7F);
         if ((chData & 0x80) == 0) {
             return n;
         }
         if (n == std::numeric_limits<I>::max()) {
             throw std::ios_base::failure("ReadVarInt(): size too large");
         }
         n++;
     }
 }
 
-#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.
  */
 class CFlatData {
 protected:
     char *pbegin;
     char *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; }
 
     template <typename Stream> void Serialize(Stream &s) const {
         s.write(pbegin, pend - pbegin);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         s.read(pbegin, pend - pbegin);
     }
 };
 
 template <typename I> class CVarInt {
 protected:
     I &n;
 
 public:
     explicit CVarInt(I &nIn) : n(nIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteVarInt<Stream, I>(s, n);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         n = ReadVarInt<Stream, I>(s);
     }
 };
 
 class CCompactSize {
 protected:
     uint64_t &n;
 
 public:
     explicit CCompactSize(uint64_t &nIn) : n(nIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteCompactSize<Stream>(s, n);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         n = ReadCompactSize<Stream>(s);
     }
 };
 
 template <size_t Limit> class LimitedString {
 protected:
     std::string &string;
 
 public:
     explicit LimitedString(std::string &_string) : string(_string) {}
 
     template <typename Stream> void Unserialize(Stream &s) {
         size_t size = ReadCompactSize(s);
         if (size > Limit) {
             throw std::ios_base::failure("String length limit exceeded");
         }
         string.resize(size);
         if (size != 0) {
             s.read((char *)&string[0], size);
         }
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteCompactSize(s, string.size());
         if (!string.empty()) {
             s.write((char *)&string[0], string.size());
         }
     }
 };
 
 template <typename I> CVarInt<I> WrapVarInt(I &n) {
     return CVarInt<I>(n);
 }
 
 /**
  * Forward declarations
  */
 
 /**
  *  string
  */
 template <typename Stream, typename C>
 void Serialize(Stream &os, const std::basic_string<C> &str);
 template <typename Stream, typename C>
 void Unserialize(Stream &is, std::basic_string<C> &str);
 
 /**
  * prevector
  * prevectors of uint8_t are a special case and are intended to be serialized as
  * a single opaque blob.
  */
 template <typename Stream, unsigned int N, typename T>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const uint8_t &);
 template <typename Stream, unsigned int N, typename T, typename V>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const V &);
 template <typename Stream, unsigned int N, typename T>
 inline void Serialize(Stream &os, const prevector<N, T> &v);
 template <typename Stream, unsigned int N, typename T>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const uint8_t &);
 template <typename Stream, unsigned int N, typename T, typename V>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const V &);
 template <typename Stream, unsigned int N, typename T>
 inline void Unserialize(Stream &is, prevector<N, T> &v);
 
 /**
  * vector
  * vectors of uint8_t are a special case and are intended to be serialized as a
  * single opaque blob.
  */
 template <typename Stream, typename T, typename A>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const uint8_t &);
 template <typename Stream, typename T, typename A, typename V>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const V &);
 template <typename Stream, typename T, typename A>
 inline void Serialize(Stream &os, const std::vector<T, A> &v);
 template <typename Stream, typename T, typename A>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const uint8_t &);
 template <typename Stream, typename T, typename A, typename V>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const V &);
 template <typename Stream, typename T, typename A>
 inline void Unserialize(Stream &is, std::vector<T, A> &v);
 
 /**
  * pair
  */
 template <typename Stream, typename K, typename T>
 void Serialize(Stream &os, const std::pair<K, T> &item);
 template <typename Stream, typename K, typename T>
 void Unserialize(Stream &is, std::pair<K, T> &item);
 
 /**
  * map
  */
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Serialize(Stream &os, const std::map<K, T, Pred, A> &m);
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Unserialize(Stream &is, std::map<K, T, Pred, A> &m);
 
 /**
  * set
  */
 template <typename Stream, typename K, typename Pred, typename A>
 void Serialize(Stream &os, const std::set<K, Pred, A> &m);
 template <typename Stream, typename K, typename Pred, typename A>
 void Unserialize(Stream &is, std::set<K, Pred, A> &m);
 
 /**
  * shared_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::shared_ptr<const T> &p);
 template <typename Stream, typename T>
 void Unserialize(Stream &os, std::shared_ptr<const T> &p);
 
 /**
  * unique_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::unique_ptr<const T> &p);
 template <typename Stream, typename T>
 void Unserialize(Stream &os, std::unique_ptr<const T> &p);
 
 /**
  * If none of the specialized versions above matched, default to calling member
  * function.
  */
 template <typename Stream, typename T>
 inline void Serialize(Stream &os, const T &a) {
     a.Serialize(os);
 }
 
 template <typename Stream, typename T>
-inline void Unserialize(Stream &is, T &a) {
+inline void Unserialize(Stream &is, T &&a) {
     a.Unserialize(is);
 }
 
 /**
  * string
  */
 template <typename Stream, typename C>
 void Serialize(Stream &os, const std::basic_string<C> &str) {
     WriteCompactSize(os, str.size());
     if (!str.empty()) {
         os.write((char *)&str[0], str.size() * sizeof(str[0]));
     }
 }
 
 template <typename Stream, typename C>
 void Unserialize(Stream &is, std::basic_string<C> &str) {
     size_t nSize = ReadCompactSize(is);
     str.resize(nSize);
     if (nSize != 0) {
         is.read((char *)&str[0], nSize * sizeof(str[0]));
     }
 }
 
 /**
  * prevector
  */
 template <typename Stream, unsigned int N, typename T>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const uint8_t &) {
     WriteCompactSize(os, v.size());
     if (!v.empty()) {
         os.write((char *)&v[0], v.size() * sizeof(T));
     }
 }
 
 template <typename Stream, unsigned int N, typename T, typename V>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const V &) {
     WriteCompactSize(os, v.size());
     for (const T &i : v) {
         ::Serialize(os, i);
     }
 }
 
 template <typename Stream, unsigned int N, typename T>
 inline void Serialize(Stream &os, const prevector<N, T> &v) {
     Serialize_impl(os, v, T());
 }
 
 template <typename Stream, unsigned int N, typename T>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const uint8_t &) {
     // Limit size per read so bogus size value won't cause out of memory
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     while (i < nSize) {
         size_t blk = std::min(nSize - i, size_t(1 + 4999999 / sizeof(T)));
         v.resize(i + blk);
         is.read((char *)&v[i], blk * sizeof(T));
         i += blk;
     }
 }
 
 template <typename Stream, unsigned int N, typename T, typename V>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const V &) {
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     size_t nMid = 0;
     while (nMid < nSize) {
         nMid += 5000000 / sizeof(T);
         if (nMid > nSize) {
             nMid = nSize;
         }
         v.resize(nMid);
         for (; i < nMid; i++) {
             Unserialize(is, v[i]);
         }
     }
 }
 
 template <typename Stream, unsigned int N, typename T>
 inline void Unserialize(Stream &is, prevector<N, T> &v) {
     Unserialize_impl(is, v, T());
 }
 
 /**
  * vector
  */
 template <typename Stream, typename T, typename A>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const uint8_t &) {
     WriteCompactSize(os, v.size());
     if (!v.empty()) {
         os.write((char *)&v[0], v.size() * sizeof(T));
     }
 }
 
 template <typename Stream, typename T, typename A, typename V>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const V &) {
     WriteCompactSize(os, v.size());
     for (const T &i : v) {
         ::Serialize(os, i);
     }
 }
 
 template <typename Stream, typename T, typename A>
 inline void Serialize(Stream &os, const std::vector<T, A> &v) {
     Serialize_impl(os, v, T());
 }
 
 template <typename Stream, typename T, typename A>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const uint8_t &) {
     // Limit size per read so bogus size value won't cause out of memory
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     while (i < nSize) {
         size_t blk = std::min(nSize - i, size_t(1 + 4999999 / sizeof(T)));
         v.resize(i + blk);
         is.read((char *)&v[i], blk * sizeof(T));
         i += blk;
     }
 }
 
 template <typename Stream, typename T, typename A, typename V>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const V &) {
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     size_t nMid = 0;
     while (nMid < nSize) {
         nMid += 5000000 / sizeof(T);
         if (nMid > nSize) {
             nMid = nSize;
         }
         v.resize(nMid);
         for (; i < nMid; i++) {
             Unserialize(is, v[i]);
         }
     }
 }
 
 template <typename Stream, typename T, typename A>
 inline void Unserialize(Stream &is, std::vector<T, A> &v) {
     Unserialize_impl(is, v, T());
 }
 
 /**
  * pair
  */
 template <typename Stream, typename K, typename T>
 void Serialize(Stream &os, const std::pair<K, T> &item) {
     Serialize(os, item.first);
     Serialize(os, item.second);
 }
 
 template <typename Stream, typename K, typename T>
 void Unserialize(Stream &is, std::pair<K, T> &item) {
     Unserialize(is, item.first);
     Unserialize(is, item.second);
 }
 
 /**
  * map
  */
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Serialize(Stream &os, const std::map<K, T, Pred, A> &m) {
     WriteCompactSize(os, m.size());
     for (const auto &entry : m) {
         Serialize(os, entry);
     }
 }
 
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Unserialize(Stream &is, std::map<K, T, Pred, A> &m) {
     m.clear();
     size_t nSize = ReadCompactSize(is);
     typename std::map<K, T, Pred, A>::iterator mi = m.begin();
     for (size_t i = 0; i < nSize; i++) {
         std::pair<K, T> item;
         Unserialize(is, item);
         mi = m.insert(mi, item);
     }
 }
 
 /**
  * set
  */
 template <typename Stream, typename K, typename Pred, typename A>
 void Serialize(Stream &os, const std::set<K, Pred, A> &m) {
     WriteCompactSize(os, m.size());
     for (const K &i : m) {
         Serialize(os, i);
     }
 }
 
 template <typename Stream, typename K, typename Pred, typename A>
 void Unserialize(Stream &is, std::set<K, Pred, A> &m) {
     m.clear();
     size_t nSize = ReadCompactSize(is);
     typename std::set<K, Pred, A>::iterator it = m.begin();
     for (size_t i = 0; i < nSize; i++) {
         K key;
         Unserialize(is, key);
         it = m.insert(it, key);
     }
 }
 
 /**
  * unique_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::unique_ptr<const T> &p) {
     Serialize(os, *p);
 }
 
 template <typename Stream, typename T>
 void Unserialize(Stream &is, std::unique_ptr<const T> &p) {
     p.reset(new T(deserialize, is));
 }
 
 /**
  * shared_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::shared_ptr<const T> &p) {
     Serialize(os, *p);
 }
 
 template <typename Stream, typename T>
 void Unserialize(Stream &is, std::shared_ptr<const T> &p) {
     p = std::make_shared<const T>(deserialize, is);
 }
 
 /**
  * Support for ADD_SERIALIZE_METHODS and READWRITE macro
  */
 struct CSerActionSerialize {
     constexpr bool ForRead() const { return false; }
 };
 struct CSerActionUnserialize {
     constexpr bool ForRead() const { return true; }
 };
 
 /**
  * ::GetSerializeSize implementations
  *
  * Computing the serialized size of objects is done through a special stream
  * object of type CSizeComputer, which only records the number of bytes written
  * to it.
  *
  * If your Serialize or SerializationOp method has non-trivial overhead for
  * serialization, it may be worthwhile to implement a specialized version for
  * CSizeComputer, which uses the s.seek() method to record bytes that would
  * be written instead.
  */
 class CSizeComputer {
 protected:
     size_t nSize;
 
     const int nType;
     const int nVersion;
 
 public:
     CSizeComputer(int nTypeIn, int nVersionIn)
         : nSize(0), nType(nTypeIn), nVersion(nVersionIn) {}
 
     void write(const char *psz, size_t _nSize) { this->nSize += _nSize; }
 
     /** Pretend _nSize bytes are written, without specifying them. */
     void seek(size_t _nSize) { this->nSize += _nSize; }
 
     template <typename T> CSizeComputer &operator<<(const T &obj) {
         ::Serialize(*this, obj);
         return (*this);
     }
 
     size_t size() const { return nSize; }
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 };
 
 template <typename Stream> void SerializeMany(Stream &s) {}
 
 template <typename Stream, typename Arg, typename... Args>
-void SerializeMany(Stream &s, Arg &&arg, Args &&... args) {
-    ::Serialize(s, std::forward<Arg>(arg));
-    ::SerializeMany(s, std::forward<Args>(args)...);
+void SerializeMany(Stream &s, const Arg &arg, const Args &... args) {
+    ::Serialize(s, arg);
+    ::SerializeMany(s, args...);
 }
 
 template <typename Stream> inline void UnserializeMany(Stream &s) {}
 
 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) {
-    ::SerializeMany(s, std::forward<Args>(args)...);
+                             const Args &... args) {
+    ::SerializeMany(s, args...);
 }
 
 template <typename Stream, typename... Args>
 inline void SerReadWriteMany(Stream &s, CSerActionUnserialize ser_action,
-                             Args &... args) {
+                             Args &&... args) {
     ::UnserializeMany(s, args...);
 }
 
 template <typename I> inline void WriteVarInt(CSizeComputer &s, I n) {
     s.seek(GetSizeOfVarInt<I>(n));
 }
 
 inline void WriteCompactSize(CSizeComputer &s, uint64_t nSize) {
     s.seek(GetSizeOfCompactSize(nSize));
 }
 
 template <typename T>
 size_t GetSerializeSize(const T &t, int nType, int nVersion = 0) {
     return (CSizeComputer(nType, nVersion) << t).size();
 }
 
 template <typename S, typename T>
 size_t GetSerializeSize(const S &s, const T &t) {
     return (CSizeComputer(s.GetType(), s.GetVersion()) << t).size();
 }
 
 #endif // BITCOIN_SERIALIZE_H
diff --git a/src/streams.h b/src/streams.h
index f264e2c97..6c97bc124 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -1,820 +1,820 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_STREAMS_H
 #define BITCOIN_STREAMS_H
 
 #include <serialize.h>
 #include <support/allocators/zeroafterfree.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <ios>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 template <typename Stream> class OverrideStream {
     Stream *stream;
 
     const int nType;
     const int nVersion;
 
 public:
     OverrideStream(Stream *stream_, int nType_, int nVersion_)
         : stream(stream_), nType(nType_), nVersion(nVersion_) {}
 
     template <typename T> OverrideStream<Stream> &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 
-    template <typename T> OverrideStream<Stream> &operator>>(T &obj) {
+    template <typename T> OverrideStream<Stream> &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     void write(const char *pch, size_t nSize) { stream->write(pch, nSize); }
 
     void read(char *pch, size_t nSize) { stream->read(pch, nSize); }
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 };
 
 template <typename S> OverrideStream<S> WithOrVersion(S *s, int nVersionFlag) {
     return OverrideStream<S>(s, s->GetType(), s->GetVersion() | nVersionFlag);
 }
 
 /**
  * Minimal stream for overwriting and/or appending to an existing byte vector.
  *
  * The referenced vector will grow as necessary.
  */
 class CVectorWriter {
 public:
     /**
      * @param[in]  nTypeIn Serialization Type
      * @param[in]  nVersionIn Serialization Version (including any flags)
      * @param[in]  vchDataIn  Referenced byte vector to overwrite/append
      * @param[in]  nPosIn Starting position. Vector index where writes should
      * start. The vector will initially grow as necessary to max(index,
      * vec.size()). So to append, use vec.size().
      */
     CVectorWriter(int nTypeIn, int nVersionIn, std::vector<uint8_t> &vchDataIn,
                   size_t nPosIn)
         : nType(nTypeIn), nVersion(nVersionIn), vchData(vchDataIn),
           nPos(nPosIn) {
         if (nPos > vchData.size()) vchData.resize(nPos);
     }
     /**
      * (other params same as above)
      * @param[in]  args  A list of items to serialize starting at nPos.
      */
     template <typename... Args>
     CVectorWriter(int nTypeIn, int nVersionIn, std::vector<uint8_t> &vchDataIn,
                   size_t nPosIn, Args &&... args)
         : CVectorWriter(nTypeIn, nVersionIn, vchDataIn, nPosIn) {
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
     void write(const char *pch, size_t nSize) {
         assert(nPos <= vchData.size());
         size_t nOverwrite = std::min(nSize, vchData.size() - nPos);
         if (nOverwrite) {
             memcpy(vchData.data() + nPos,
                    reinterpret_cast<const uint8_t *>(pch), nOverwrite);
         }
         if (nOverwrite < nSize) {
             vchData.insert(vchData.end(),
                            reinterpret_cast<const uint8_t *>(pch) + nOverwrite,
                            reinterpret_cast<const uint8_t *>(pch) + nSize);
         }
         nPos += nSize;
     }
     template <typename T> CVectorWriter &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
     void seek(size_t nSize) {
         nPos += nSize;
         if (nPos > vchData.size()) vchData.resize(nPos);
     }
 
 private:
     const int nType;
     const int nVersion;
     std::vector<uint8_t> &vchData;
     size_t nPos;
 };
 
 /**
  * Minimal stream for reading from an existing vector by reference
  */
 class VectorReader {
 private:
     const int m_type;
     const int m_version;
     const std::vector<uint8_t> &m_data;
     size_t m_pos = 0;
 
 public:
     /**
      * @param[in]  type Serialization Type
      * @param[in]  version Serialization Version (including any flags)
      * @param[in]  data Referenced byte vector to overwrite/append
      * @param[in]  pos Starting position. Vector index where reads should start.
      */
     VectorReader(int type, int version, const std::vector<uint8_t> &data,
                  size_t pos)
         : m_type(type), m_version(version), m_data(data), m_pos(pos) {
         if (m_pos > m_data.size()) {
             throw std::ios_base::failure(
                 "VectorReader(...): end of data (m_pos > m_data.size())");
         }
     }
 
     /**
      * (other params same as above)
      * @param[in]  args  A list of items to deserialize starting at pos.
      */
     template <typename... Args>
     VectorReader(int type, int version, const std::vector<uint8_t> &data,
                  size_t pos, Args &&... args)
         : VectorReader(type, version, data, pos) {
         ::UnserializeMany(*this, std::forward<Args>(args)...);
     }
 
     template <typename T> VectorReader &operator>>(T &obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     int GetVersion() const { return m_version; }
     int GetType() const { return m_type; }
 
     size_t size() const { return m_data.size() - m_pos; }
     bool empty() const { return m_data.size() == m_pos; }
 
     void read(char *dst, size_t n) {
         if (n == 0) {
             return;
         }
 
         // Read from the beginning of the buffer
         size_t pos_next = m_pos + n;
         if (pos_next > m_data.size()) {
             throw std::ios_base::failure("VectorReader::read(): end of data");
         }
         memcpy(dst, m_data.data() + m_pos, n);
         m_pos = pos_next;
     }
 };
 
 /**
  * Double ended buffer combining vector and stream-like interfaces.
  *
  * >> and << read and write unformatted data using the above serialization
  * templates. Fills with data in linear time; some stringstream implementations
  * take N^2 time.
  */
 class CDataStream {
 protected:
     typedef CSerializeData vector_type;
     vector_type vch;
     unsigned int nReadPos;
 
     int nType;
     int nVersion;
 
 public:
     typedef vector_type::allocator_type allocator_type;
     typedef vector_type::size_type size_type;
     typedef vector_type::difference_type difference_type;
     typedef vector_type::reference reference;
     typedef vector_type::const_reference const_reference;
     typedef vector_type::value_type value_type;
     typedef vector_type::iterator iterator;
     typedef vector_type::const_iterator const_iterator;
     typedef vector_type::reverse_iterator reverse_iterator;
 
     explicit CDataStream(int nTypeIn, int nVersionIn) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn,
                 int nVersionIn)
         : vch(pbegin, pend) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const char *pbegin, const char *pend, int nTypeIn,
                 int nVersionIn)
         : vch(pbegin, pend) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const vector_type &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const std::vector<char> &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const std::vector<uint8_t> &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     template <typename... Args>
     CDataStream(int nTypeIn, int nVersionIn, Args &&... args) {
         Init(nTypeIn, nVersionIn);
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
 
     void Init(int nTypeIn, int nVersionIn) {
         nReadPos = 0;
         nType = nTypeIn;
         nVersion = nVersionIn;
     }
 
     CDataStream &operator+=(const CDataStream &b) {
         vch.insert(vch.end(), b.begin(), b.end());
         return *this;
     }
 
     friend CDataStream operator+(const CDataStream &a, const CDataStream &b) {
         CDataStream ret = a;
         ret += b;
         return (ret);
     }
 
     std::string str() const { return (std::string(begin(), end())); }
 
     //
     // Vector subset
     //
     const_iterator begin() const { return vch.begin() + nReadPos; }
     iterator begin() { return vch.begin() + nReadPos; }
     const_iterator end() const { return vch.end(); }
     iterator end() { return vch.end(); }
     size_type size() const { return vch.size() - nReadPos; }
     bool empty() const { return vch.size() == nReadPos; }
     void resize(size_type n, value_type c = 0) { vch.resize(n + nReadPos, c); }
     void reserve(size_type n) { vch.reserve(n + nReadPos); }
     const_reference operator[](size_type pos) const {
         return vch[pos + nReadPos];
     }
     reference operator[](size_type pos) { return vch[pos + nReadPos]; }
     void clear() {
         vch.clear();
         nReadPos = 0;
     }
     iterator insert(iterator it, const char x = char()) {
         return vch.insert(it, x);
     }
     void insert(iterator it, size_type n, const char x) {
         vch.insert(it, n, x);
     }
     value_type *data() { return vch.data() + nReadPos; }
     const value_type *data() const { return vch.data() + nReadPos; }
 
     void insert(iterator it, std::vector<char>::const_iterator first,
                 std::vector<char>::const_iterator last) {
         if (last == first) {
             return;
         }
 
         assert(last - first > 0);
         if (it == vch.begin() + nReadPos &&
             (unsigned int)(last - first) <= nReadPos) {
             // special case for inserting at the front when there's room
             nReadPos -= (last - first);
             memcpy(&vch[nReadPos], &first[0], last - first);
         } else {
             vch.insert(it, first, last);
         }
     }
 
     void insert(iterator it, const char *first, const char *last) {
         if (last == first) {
             return;
         }
 
         assert(last - first > 0);
         if (it == vch.begin() + nReadPos &&
             (unsigned int)(last - first) <= nReadPos) {
             // special case for inserting at the front when there's room
             nReadPos -= (last - first);
             memcpy(&vch[nReadPos], &first[0], last - first);
         } else {
             vch.insert(it, first, last);
         }
     }
 
     iterator erase(iterator it) {
         if (it == vch.begin() + nReadPos) {
             // special case for erasing from the front
             if (++nReadPos >= vch.size()) {
                 // whenever we reach the end, we take the opportunity to clear
                 // the buffer
                 nReadPos = 0;
                 return vch.erase(vch.begin(), vch.end());
             }
             return vch.begin() + nReadPos;
         } else {
             return vch.erase(it);
         }
     }
 
     iterator erase(iterator first, iterator last) {
         if (first == vch.begin() + nReadPos) {
             // special case for erasing from the front
             if (last == vch.end()) {
                 nReadPos = 0;
                 return vch.erase(vch.begin(), vch.end());
             } else {
                 nReadPos = (last - vch.begin());
                 return last;
             }
         } else
             return vch.erase(first, last);
     }
 
     inline void Compact() {
         vch.erase(vch.begin(), vch.begin() + nReadPos);
         nReadPos = 0;
     }
 
     bool Rewind(size_type n) {
         // Rewind by n characters if the buffer hasn't been compacted yet
         if (n > nReadPos) return false;
         nReadPos -= n;
         return true;
     }
 
     //
     // Stream subset
     //
     bool eof() const { return size() == 0; }
     CDataStream *rdbuf() { return this; }
     int in_avail() const { return size(); }
 
     void SetType(int n) { nType = n; }
     int GetType() const { return nType; }
     void SetVersion(int n) { nVersion = n; }
     int GetVersion() const { return nVersion; }
 
     void read(char *pch, size_t nSize) {
         if (nSize == 0) {
             return;
         }
 
         // Read from the beginning of the buffer
         unsigned int nReadPosNext = nReadPos + nSize;
         if (nReadPosNext > vch.size()) {
             throw std::ios_base::failure("CDataStream::read(): end of data");
         }
         memcpy(pch, &vch[nReadPos], nSize);
         if (nReadPosNext == vch.size()) {
             nReadPos = 0;
             vch.clear();
             return;
         }
         nReadPos = nReadPosNext;
     }
 
     void ignore(int nSize) {
         // Ignore from the beginning of the buffer
         if (nSize < 0) {
             throw std::ios_base::failure(
                 "CDataStream::ignore(): nSize negative");
         }
         unsigned int nReadPosNext = nReadPos + nSize;
         if (nReadPosNext >= vch.size()) {
             if (nReadPosNext > vch.size())
                 throw std::ios_base::failure(
                     "CDataStream::ignore(): end of data");
             nReadPos = 0;
             vch.clear();
             return;
         }
         nReadPos = nReadPosNext;
     }
 
     void write(const char *pch, size_t nSize) {
         // Write to the end of the buffer
         vch.insert(vch.end(), pch, pch + nSize);
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         // Special case: stream << stream concatenates like stream += stream
         if (!vch.empty()) s.write((char *)&vch[0], vch.size() * sizeof(vch[0]));
     }
 
     template <typename T> CDataStream &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 
-    template <typename T> CDataStream &operator>>(T &obj) {
+    template <typename T> CDataStream &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     void GetAndClear(CSerializeData &d) {
         d.insert(d.end(), begin(), end());
         clear();
     }
 
     /**
      * XOR the contents of this stream with a certain key.
      *
      * @param[in] key    The key used to XOR the data in this stream.
      */
     void Xor(const std::vector<uint8_t> &key) {
         if (key.size() == 0) {
             return;
         }
 
         for (size_type i = 0, j = 0; i != size(); i++) {
             vch[i] ^= key[j++];
 
             // This potentially acts on very many bytes of data, so it's
             // important that we calculate `j`, i.e. the `key` index in this way
             // instead of doing a %, which would effectively be a division for
             // each byte Xor'd -- much slower than need be.
             if (j == key.size()) j = 0;
         }
     }
 };
 
 template <typename IStream> class BitStreamReader {
 private:
     IStream &m_istream;
 
     /// Buffered byte read in from the input stream. A new byte is read into the
     /// buffer when m_offset reaches 8.
     uint8_t m_buffer{0};
 
     /// Number of high order bits in m_buffer already returned by previous
     /// Read() calls. The next bit to be returned is at this offset from the
     /// most significant bit position.
     int m_offset{8};
 
 public:
     explicit BitStreamReader(IStream &istream) : m_istream(istream) {}
 
     /**
      * Read the specified number of bits from the stream. The data is returned
      * in the nbits least significant bits of a 64-bit uint.
      */
     uint64_t Read(int nbits) {
         if (nbits < 0 || nbits > 64) {
             throw std::out_of_range("nbits must be between 0 and 64");
         }
 
         uint64_t data = 0;
         while (nbits > 0) {
             if (m_offset == 8) {
                 m_istream >> m_buffer;
                 m_offset = 0;
             }
 
             int bits = std::min(8 - m_offset, nbits);
             data <<= bits;
             data |= static_cast<uint8_t>(m_buffer << m_offset) >> (8 - bits);
             m_offset += bits;
             nbits -= bits;
         }
         return data;
     }
 };
 
 template <typename OStream> class BitStreamWriter {
 private:
     OStream &m_ostream;
 
     /// Buffered byte waiting to be written to the output stream. The byte is
     /// written buffer when m_offset reaches 8 or Flush() is called.
     uint8_t m_buffer{0};
 
     /// Number of high order bits in m_buffer already written by previous
     /// Write() calls and not yet flushed to the stream. The next bit to be
     /// written to is at this offset from the most significant bit position.
     int m_offset{0};
 
 public:
     explicit BitStreamWriter(OStream &ostream) : m_ostream(ostream) {}
 
     ~BitStreamWriter() { Flush(); }
 
     /**
      * Write the nbits least significant bits of a 64-bit int to the output
      * stream. Data is buffered until it completes an octet.
      */
     void Write(uint64_t data, int nbits) {
         if (nbits < 0 || nbits > 64) {
             throw std::out_of_range("nbits must be between 0 and 64");
         }
 
         while (nbits > 0) {
             int bits = std::min(8 - m_offset, nbits);
             m_buffer |= (data << (64 - nbits)) >> (64 - 8 + m_offset);
             m_offset += bits;
             nbits -= bits;
 
             if (m_offset == 8) {
                 Flush();
             }
         }
     }
 
     /**
      * Flush any unwritten bits to the output stream, padding with 0's to the
      * next byte boundary.
      */
     void Flush() {
         if (m_offset == 0) {
             return;
         }
 
         m_ostream << m_buffer;
         m_buffer = 0;
         m_offset = 0;
     }
 };
 
 /**
  * Non-refcounted RAII wrapper for FILE*
  *
  * Will automatically close the file when it goes out of scope if not null. If
  * you're returning the file pointer, return file.release(). If you need to
  * close the file early, use file.fclose() instead of fclose(file).
  */
 class CAutoFile {
 private:
     // Disallow copies
     CAutoFile(const CAutoFile &);
     CAutoFile &operator=(const CAutoFile &);
 
     const int nType;
     const int nVersion;
 
     FILE *file;
 
 public:
     CAutoFile(FILE *filenew, int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn) {
         file = filenew;
     }
 
     ~CAutoFile() { fclose(); }
 
     void fclose() {
         if (file) {
             ::fclose(file);
             file = nullptr;
         }
     }
 
     /**
      * Get wrapped FILE* with transfer of ownership.
      * @note This will invalidate the CAutoFile object, and makes it the
      * responsibility of the caller of this function to clean up the returned
      * FILE*.
      */
     FILE *release() {
         FILE *ret = file;
         file = nullptr;
         return ret;
     }
 
     /**
      * Get wrapped FILE* without transfer of ownership.
      * @note Ownership of the FILE* will remain with this class. Use this only
      * if the scope of the CAutoFile outlives use of the passed pointer.
      */
     FILE *Get() const { return file; }
 
     /** Return true if the wrapped FILE* is nullptr, false otherwise. */
     bool IsNull() const { return (file == nullptr); }
 
     //
     // Stream subset
     //
     int GetType() const { return nType; }
     int GetVersion() const { return nVersion; }
 
     void read(char *pch, size_t nSize) {
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::read: file handle is nullptr");
         if (fread(pch, 1, nSize, file) != nSize)
             throw std::ios_base::failure(feof(file)
                                              ? "CAutoFile::read: end of file"
                                              : "CAutoFile::read: fread failed");
     }
 
     void ignore(size_t nSize) {
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::ignore: file handle is nullptr");
         uint8_t data[4096];
         while (nSize > 0) {
             size_t nNow = std::min<size_t>(nSize, sizeof(data));
             if (fread(data, 1, nNow, file) != nNow)
                 throw std::ios_base::failure(
                     feof(file) ? "CAutoFile::ignore: end of file"
                                : "CAutoFile::read: fread failed");
             nSize -= nNow;
         }
     }
 
     void write(const char *pch, size_t nSize) {
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::write: file handle is nullptr");
         if (fwrite(pch, 1, nSize, file) != nSize)
             throw std::ios_base::failure("CAutoFile::write: write failed");
     }
 
     template <typename T> CAutoFile &operator<<(const T &obj) {
         // Serialize to this stream
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::operator<<: file handle is nullptr");
         ::Serialize(*this, obj);
         return (*this);
     }
 
-    template <typename T> CAutoFile &operator>>(T &obj) {
+    template <typename T> CAutoFile &operator>>(T &&obj) {
         // Unserialize from this stream
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::operator>>: file handle is nullptr");
         ::Unserialize(*this, obj);
         return (*this);
     }
 };
 
 /**
  * Non-refcounted RAII wrapper around a FILE* that implements a ring buffer to
  * deserialize from. It guarantees the ability to rewind a given number of
  * bytes.
  *
  * Will automatically close the file when it goes out of scope if not null. If
  * you need to close the file early, use file.fclose() instead of fclose(file).
  */
 class CBufferedFile {
 private:
     // Disallow copies
     CBufferedFile(const CBufferedFile &);
     CBufferedFile &operator=(const CBufferedFile &);
 
     const int nType;
     const int nVersion;
 
     // source file
     FILE *src;
     // how many bytes have been read from source
     uint64_t nSrcPos;
     // how many bytes have been read from this
     uint64_t nReadPos;
     // up to which position we're allowed to read
     uint64_t nReadLimit;
     // how many bytes we guarantee to rewind
     uint64_t nRewind;
     // the buffer
     std::vector<char> vchBuf;
 
 protected:
     // read data from the source to fill the buffer
     bool Fill() {
         unsigned int pos = nSrcPos % vchBuf.size();
         unsigned int readNow = vchBuf.size() - pos;
         unsigned int nAvail = vchBuf.size() - (nSrcPos - nReadPos) - nRewind;
         if (nAvail < readNow) readNow = nAvail;
         if (readNow == 0) return false;
         size_t nBytes = fread((void *)&vchBuf[pos], 1, readNow, src);
         if (nBytes == 0) {
             throw std::ios_base::failure(
                 feof(src) ? "CBufferedFile::Fill: end of file"
                           : "CBufferedFile::Fill: fread failed");
         } else {
             nSrcPos += nBytes;
             return true;
         }
     }
 
 public:
     CBufferedFile(FILE *fileIn, uint64_t nBufSize, uint64_t nRewindIn,
                   int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn), nSrcPos(0), nReadPos(0),
           nReadLimit((uint64_t)(-1)), nRewind(nRewindIn), vchBuf(nBufSize, 0) {
         src = fileIn;
     }
 
     ~CBufferedFile() { fclose(); }
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 
     void fclose() {
         if (src) {
             ::fclose(src);
             src = nullptr;
         }
     }
 
     // check whether we're at the end of the source file
     bool eof() const { return nReadPos == nSrcPos && feof(src); }
 
     // read a number of bytes
     void read(char *pch, size_t nSize) {
         if (nSize + nReadPos > nReadLimit)
             throw std::ios_base::failure("Read attempted past buffer limit");
         if (nSize + nRewind > vchBuf.size())
             throw std::ios_base::failure("Read larger than buffer size");
         while (nSize > 0) {
             if (nReadPos == nSrcPos) Fill();
             unsigned int pos = nReadPos % vchBuf.size();
             size_t nNow = nSize;
             if (nNow + pos > vchBuf.size()) nNow = vchBuf.size() - pos;
             if (nNow + nReadPos > nSrcPos) nNow = nSrcPos - nReadPos;
             memcpy(pch, &vchBuf[pos], nNow);
             nReadPos += nNow;
             pch += nNow;
             nSize -= nNow;
         }
     }
 
     // return the current reading position
     uint64_t GetPos() const { return nReadPos; }
 
     // rewind to a given reading position
     bool SetPos(uint64_t nPos) {
         nReadPos = nPos;
         if (nReadPos + nRewind < nSrcPos) {
             nReadPos = nSrcPos - nRewind;
             return false;
         } else if (nReadPos > nSrcPos) {
             nReadPos = nSrcPos;
             return false;
         } else {
             return true;
         }
     }
 
     bool Seek(uint64_t nPos) {
         long nLongPos = nPos;
         if (nPos != (uint64_t)nLongPos) return false;
         if (fseek(src, nLongPos, SEEK_SET)) return false;
         nLongPos = ftell(src);
         nSrcPos = nLongPos;
         nReadPos = nLongPos;
         return true;
     }
 
     // Prevent reading beyond a certain position. No argument removes the limit.
     bool SetLimit(uint64_t nPos = (uint64_t)(-1)) {
         if (nPos < nReadPos) return false;
         nReadLimit = nPos;
         return true;
     }
 
-    template <typename T> CBufferedFile &operator>>(T &obj) {
+    template <typename T> CBufferedFile &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     // search for a given byte in the stream, and remain positioned on it
     void FindByte(char ch) {
         while (true) {
             if (nReadPos == nSrcPos) Fill();
             if (vchBuf[nReadPos % vchBuf.size()] == ch) break;
             nReadPos++;
         }
     }
 };
 
 #endif // BITCOIN_STREAMS_H
diff --git a/src/txdb.cpp b/src/txdb.cpp
index d8b156ab7..ce9882572 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -1,628 +1,628 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <txdb.h>
 
 #include <chainparams.h>
 #include <hash.h>
 #include <init.h>
 #include <pow.h>
 #include <random.h>
 #include <ui_interface.h>
 #include <uint256.h>
 #include <util.h>
 
 #include <boost/thread.hpp>
 
 #include <cstdint>
 
 static const char DB_COIN = 'C';
 static const char DB_COINS = 'c';
 static const char DB_BLOCK_FILES = 'f';
 static const char DB_TXINDEX = 't';
 static const char DB_TXINDEX_BLOCK = 'T';
 static const char DB_BLOCK_INDEX = 'b';
 
 static const char DB_BEST_BLOCK = 'B';
 static const char DB_HEAD_BLOCKS = 'H';
 static const char DB_FLAG = 'F';
 static const char DB_REINDEX_FLAG = 'R';
 static const char DB_LAST_BLOCK = 'l';
 
 namespace {
 
 struct CoinEntry {
     COutPoint *outpoint;
     char key;
     explicit CoinEntry(const COutPoint *ptr)
         : outpoint(const_cast<COutPoint *>(ptr)), key(DB_COIN) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         s << key;
         s << outpoint->GetTxId();
         s << VARINT(outpoint->GetN());
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         s >> key;
         uint256 id;
         s >> id;
         uint32_t n = 0;
         s >> VARINT(n);
         *outpoint = COutPoint(id, n);
     }
 };
 } // namespace
 
 CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe)
     : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe, true) {}
 
 bool CCoinsViewDB::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     return db.Read(CoinEntry(&outpoint), coin);
 }
 
 bool CCoinsViewDB::HaveCoin(const COutPoint &outpoint) const {
     return db.Exists(CoinEntry(&outpoint));
 }
 
 uint256 CCoinsViewDB::GetBestBlock() const {
     uint256 hashBestChain;
     if (!db.Read(DB_BEST_BLOCK, hashBestChain)) return uint256();
     return hashBestChain;
 }
 
 std::vector<uint256> CCoinsViewDB::GetHeadBlocks() const {
     std::vector<uint256> vhashHeadBlocks;
     if (!db.Read(DB_HEAD_BLOCKS, vhashHeadBlocks)) {
         return std::vector<uint256>();
     }
     return vhashHeadBlocks;
 }
 
 bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
     CDBBatch batch(db);
     size_t count = 0;
     size_t changed = 0;
     size_t batch_size =
         (size_t)gArgs.GetArg("-dbbatchsize", nDefaultDbBatchSize);
     int crash_simulate = gArgs.GetArg("-dbcrashratio", 0);
     assert(!hashBlock.IsNull());
 
     uint256 old_tip = GetBestBlock();
     if (old_tip.IsNull()) {
         // We may be in the middle of replaying.
         std::vector<uint256> old_heads = GetHeadBlocks();
         if (old_heads.size() == 2) {
             assert(old_heads[0] == hashBlock);
             old_tip = old_heads[1];
         }
     }
 
     // In the first batch, mark the database as being in the middle of a
     // transition from old_tip to hashBlock.
     // A vector is used for future extensibility, as we may want to support
     // interrupting after partial writes from multiple independent reorgs.
     batch.Erase(DB_BEST_BLOCK);
     batch.Write(DB_HEAD_BLOCKS, std::vector<uint256>{hashBlock, old_tip});
 
     for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
         if (it->second.flags & CCoinsCacheEntry::DIRTY) {
             CoinEntry entry(&it->first);
             if (it->second.coin.IsSpent()) {
                 batch.Erase(entry);
             } else {
                 batch.Write(entry, it->second.coin);
             }
             changed++;
         }
         count++;
         CCoinsMap::iterator itOld = it++;
         mapCoins.erase(itOld);
         if (batch.SizeEstimate() > batch_size) {
             LogPrint(BCLog::COINDB, "Writing partial batch of %.2f MiB\n",
                      batch.SizeEstimate() * (1.0 / 1048576.0));
             db.WriteBatch(batch);
             batch.Clear();
             if (crash_simulate) {
                 static FastRandomContext rng;
                 if (rng.randrange(crash_simulate) == 0) {
                     LogPrintf("Simulating a crash. Goodbye.\n");
                     _Exit(0);
                 }
             }
         }
     }
 
     // In the last batch, mark the database as consistent with hashBlock again.
     batch.Erase(DB_HEAD_BLOCKS);
     batch.Write(DB_BEST_BLOCK, hashBlock);
 
     LogPrint(BCLog::COINDB, "Writing final batch of %.2f MiB\n",
              batch.SizeEstimate() * (1.0 / 1048576.0));
     bool ret = db.WriteBatch(batch);
     LogPrint(BCLog::COINDB,
              "Committed %u changed transaction outputs (out of "
              "%u) to coin database...\n",
              (unsigned int)changed, (unsigned int)count);
     return ret;
 }
 
 size_t CCoinsViewDB::EstimateSize() const {
     return db.EstimateSize(DB_COIN, char(DB_COIN + 1));
 }
 
 CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe)
     : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory,
                  fWipe) {}
 
 bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
     return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
 }
 
 bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
     if (fReindexing)
         return Write(DB_REINDEX_FLAG, '1');
     else
         return Erase(DB_REINDEX_FLAG);
 }
 
 bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
     fReindexing = Exists(DB_REINDEX_FLAG);
     return true;
 }
 
 bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
     return Read(DB_LAST_BLOCK, nFile);
 }
 
 CCoinsViewCursor *CCoinsViewDB::Cursor() const {
     CCoinsViewDBCursor *i = new CCoinsViewDBCursor(
         const_cast<CDBWrapper &>(db).NewIterator(), GetBestBlock());
     /**
      * It seems that there are no "const iterators" for LevelDB. Since we only
      * need read operations on it, use a const-cast to get around that
      * restriction.
      */
     i->pcursor->Seek(DB_COIN);
     // Cache key of first record
     if (i->pcursor->Valid()) {
         CoinEntry entry(&i->keyTmp.second);
         i->pcursor->GetKey(entry);
         i->keyTmp.first = entry.key;
     } else {
         // Make sure Valid() and GetKey() return false
         i->keyTmp.first = 0;
     }
     return i;
 }
 
 bool CCoinsViewDBCursor::GetKey(COutPoint &key) const {
     // Return cached key
     if (keyTmp.first == DB_COIN) {
         key = keyTmp.second;
         return true;
     }
     return false;
 }
 
 bool CCoinsViewDBCursor::GetValue(Coin &coin) const {
     return pcursor->GetValue(coin);
 }
 
 unsigned int CCoinsViewDBCursor::GetValueSize() const {
     return pcursor->GetValueSize();
 }
 
 bool CCoinsViewDBCursor::Valid() const {
     return keyTmp.first == DB_COIN;
 }
 
 void CCoinsViewDBCursor::Next() {
     pcursor->Next();
     CoinEntry entry(&keyTmp.second);
     if (!pcursor->Valid() || !pcursor->GetKey(entry)) {
         // Invalidate cached key after last record so that Valid() and GetKey()
         // return false
         keyTmp.first = 0;
     } else {
         keyTmp.first = entry.key;
     }
 }
 
 bool CBlockTreeDB::WriteBatchSync(
     const std::vector<std::pair<int, const CBlockFileInfo *>> &fileInfo,
     int nLastFile, const std::vector<const CBlockIndex *> &blockinfo) {
     CDBBatch batch(*this);
     for (std::vector<std::pair<int, const CBlockFileInfo *>>::const_iterator
              it = fileInfo.begin();
          it != fileInfo.end(); it++) {
         batch.Write(std::make_pair(DB_BLOCK_FILES, it->first), *it->second);
     }
     batch.Write(DB_LAST_BLOCK, nLastFile);
     for (std::vector<const CBlockIndex *>::const_iterator it =
              blockinfo.begin();
          it != blockinfo.end(); it++) {
         batch.Write(std::make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()),
                     CDiskBlockIndex(*it));
     }
     return WriteBatch(batch, true);
 }
 
 bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
     return Read(std::make_pair(DB_TXINDEX, txid), pos);
 }
 
 bool CBlockTreeDB::WriteTxIndex(
     const std::vector<std::pair<uint256, CDiskTxPos>> &vect) {
     CDBBatch batch(*this);
     for (std::vector<std::pair<uint256, CDiskTxPos>>::const_iterator it =
              vect.begin();
          it != vect.end(); it++)
         batch.Write(std::make_pair(DB_TXINDEX, it->first), it->second);
     return WriteBatch(batch);
 }
 
 bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
     return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
 }
 
 bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
     char ch;
     if (!Read(std::make_pair(DB_FLAG, name), ch)) return false;
     fValue = ch == '1';
     return true;
 }
 
 bool CBlockTreeDB::LoadBlockIndexGuts(
     const Config &config,
     std::function<CBlockIndex *(const uint256 &)> insertBlockIndex) {
 
     std::unique_ptr<CDBIterator> pcursor(NewIterator());
 
     pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
 
     // Load mapBlockIndex
     while (pcursor->Valid()) {
         boost::this_thread::interruption_point();
         std::pair<char, uint256> key;
         if (!pcursor->GetKey(key) || key.first != DB_BLOCK_INDEX) {
             break;
         }
 
         CDiskBlockIndex diskindex;
         if (!pcursor->GetValue(diskindex)) {
             return error("LoadBlockIndex() : failed to read value");
         }
 
         // Construct block index object
         CBlockIndex *pindexNew = insertBlockIndex(diskindex.GetBlockHash());
         pindexNew->pprev = insertBlockIndex(diskindex.hashPrev);
         pindexNew->nHeight = diskindex.nHeight;
         pindexNew->nFile = diskindex.nFile;
         pindexNew->nDataPos = diskindex.nDataPos;
         pindexNew->nUndoPos = diskindex.nUndoPos;
         pindexNew->nVersion = diskindex.nVersion;
         pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
         pindexNew->nTime = diskindex.nTime;
         pindexNew->nBits = diskindex.nBits;
         pindexNew->nNonce = diskindex.nNonce;
         pindexNew->nStatus = diskindex.nStatus;
         pindexNew->nTx = diskindex.nTx;
 
         if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits,
                               config)) {
             return error("LoadBlockIndex(): CheckProofOfWork failed: %s",
                          pindexNew->ToString());
         }
 
         pcursor->Next();
     }
 
     return true;
 }
 
 namespace {
 //! Legacy class to deserialize pre-pertxout database entries without reindex.
 class CCoins {
 public:
     //! whether transaction is a coinbase
     bool fCoinBase;
 
     //! unspent transaction outputs; spent outputs are .IsNull(); spent outputs
     //! at the end of the array are dropped
     std::vector<CTxOut> vout;
 
     //! at which height this transaction was included in the active block chain
     int nHeight;
 
     //! empty constructor
     CCoins() : fCoinBase(false), vout(0), nHeight(0) {}
 
     template <typename Stream> void Unserialize(Stream &s) {
         uint32_t nCode = 0;
         // version
         int nVersionDummy;
         ::Unserialize(s, VARINT(nVersionDummy));
         // header code
         ::Unserialize(s, VARINT(nCode));
         fCoinBase = nCode & 1;
         std::vector<bool> vAvail(2, false);
         vAvail[0] = (nCode & 2) != 0;
         vAvail[1] = (nCode & 4) != 0;
         uint32_t nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
         // spentness bitmask
         while (nMaskCode > 0) {
             uint8_t chAvail = 0;
             ::Unserialize(s, chAvail);
             for (unsigned int p = 0; p < 8; p++) {
                 bool f = (chAvail & (1 << p)) != 0;
                 vAvail.push_back(f);
             }
             if (chAvail != 0) {
                 nMaskCode--;
             }
         }
         // txouts themself
         vout.assign(vAvail.size(), CTxOut());
         for (size_t 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));
     }
 };
 } // namespace
 
 /**
  * Upgrade the database from older formats.
  *
  * Currently implemented: from the per-tx utxo model (0.8..0.14.x) to per-txout.
  */
 bool CCoinsViewDB::Upgrade() {
     std::unique_ptr<CDBIterator> pcursor(db.NewIterator());
     pcursor->Seek(std::make_pair(DB_COINS, uint256()));
     if (!pcursor->Valid()) {
         return true;
     }
 
     int64_t count = 0;
     LogPrintf("Upgrading utxo-set database...\n");
     LogPrintf("[0%%]...");
     uiInterface.ShowProgress(_("Upgrading UTXO database"), 0, true);
     size_t batch_size = 1 << 24;
     CDBBatch batch(db);
     int reportDone = 0;
     std::pair<uint8_t, uint256> key;
     std::pair<uint8_t, uint256> prev_key = {DB_COINS, uint256()};
     while (pcursor->Valid()) {
         boost::this_thread::interruption_point();
         if (ShutdownRequested()) {
             break;
         }
 
         if (!pcursor->GetKey(key) || key.first != DB_COINS) {
             break;
         }
 
         if (count++ % 256 == 0) {
             uint32_t high =
                 0x100 * *key.second.begin() + *(key.second.begin() + 1);
             int percentageDone = (int)(high * 100.0 / 65536.0 + 0.5);
             uiInterface.ShowProgress(_("Upgrading UTXO database"),
                                      percentageDone, true);
             if (reportDone < percentageDone / 10) {
                 // report max. every 10% step
                 LogPrintf("[%d%%]...", percentageDone);
                 reportDone = percentageDone / 10;
             }
         }
 
         CCoins old_coins;
         if (!pcursor->GetValue(old_coins)) {
             return error("%s: cannot parse CCoins record", __func__);
         }
 
         TxId id(key.second);
         for (size_t i = 0; i < old_coins.vout.size(); ++i) {
             if (!old_coins.vout[i].IsNull() &&
                 !old_coins.vout[i].scriptPubKey.IsUnspendable()) {
                 Coin newcoin(std::move(old_coins.vout[i]), old_coins.nHeight,
                              old_coins.fCoinBase);
                 COutPoint outpoint(id, i);
                 CoinEntry entry(&outpoint);
                 batch.Write(entry, newcoin);
             }
         }
 
         batch.Erase(key);
         if (batch.SizeEstimate() > batch_size) {
             db.WriteBatch(batch);
             batch.Clear();
             db.CompactRange(prev_key, key);
             prev_key = key;
         }
 
         pcursor->Next();
     }
 
     db.WriteBatch(batch);
     db.CompactRange({DB_COINS, uint256()}, key);
     uiInterface.ShowProgress("", 100, false);
     LogPrintf("[%s].\n", ShutdownRequested() ? "CANCELLED" : "DONE");
     return !ShutdownRequested();
 }
 
 TxIndexDB::TxIndexDB(size_t n_cache_size, bool f_memory, bool f_wipe)
     : CDBWrapper(GetDataDir() / "indexes" / "txindex", n_cache_size, f_memory,
                  f_wipe) {}
 
 bool TxIndexDB::ReadTxPos(const uint256 &txid, CDiskTxPos &pos) const {
     return Read(std::make_pair(DB_TXINDEX, txid), pos);
 }
 
 bool TxIndexDB::WriteTxs(
     const std::vector<std::pair<uint256, CDiskTxPos>> &v_pos) {
     CDBBatch batch(*this);
     for (const auto &tuple : v_pos) {
         batch.Write(std::make_pair(DB_TXINDEX, tuple.first), tuple.second);
     }
     return WriteBatch(batch);
 }
 
 bool TxIndexDB::ReadBestBlock(CBlockLocator &locator) const {
     bool success = Read(DB_BEST_BLOCK, locator);
     if (!success) {
         locator.SetNull();
     }
     return success;
 }
 
 bool TxIndexDB::WriteBestBlock(const CBlockLocator &locator) {
     return Write(DB_BEST_BLOCK, locator);
 }
 
 /*
  * Safely persist a transfer of data from the old txindex database to the new
  * one, and compact the range of keys updated. This is used internally by
  * MigrateData.
  */
 static void
 WriteTxIndexMigrationBatches(TxIndexDB &newdb, CBlockTreeDB &olddb,
                              CDBBatch &batch_newdb, CDBBatch &batch_olddb,
                              const std::pair<unsigned char, uint256> &begin_key,
                              const std::pair<unsigned char, uint256> &end_key) {
     // Sync new DB changes to disk before deleting from old DB.
     newdb.WriteBatch(batch_newdb, /*fSync=*/true);
     olddb.WriteBatch(batch_olddb);
     olddb.CompactRange(begin_key, end_key);
 
     batch_newdb.Clear();
     batch_olddb.Clear();
 }
 
 bool TxIndexDB::MigrateData(CBlockTreeDB &block_tree_db,
                             const CBlockLocator &best_locator) {
     // The prior implementation of txindex was always in sync with block index
     // and presence was indicated with a boolean DB flag. If the flag is set,
     // this means the txindex from a previous version is valid and in sync with
     // the chain tip. The first step of the migration is to unset the flag and
     // write the chain hash to a separate key, DB_TXINDEX_BLOCK. After that, the
     // index entries are copied over in batches to the new database. Finally,
     // DB_TXINDEX_BLOCK is erased from the old database and the block hash is
     // written to the new database.
     //
     // Unsetting the boolean flag ensures that if the node is downgraded to a
     // previous version, it will not see a corrupted, partially migrated index
     // -- it will see that the txindex is disabled. When the node is upgraded
     // again, the migration will pick up where it left off and sync to the block
     // with hash DB_TXINDEX_BLOCK.
     bool f_legacy_flag = false;
     block_tree_db.ReadFlag("txindex", f_legacy_flag);
     if (f_legacy_flag) {
         if (!block_tree_db.Write(DB_TXINDEX_BLOCK, best_locator)) {
             return error("%s: cannot write block indicator", __func__);
         }
         if (!block_tree_db.WriteFlag("txindex", false)) {
             return error("%s: cannot write block index db flag", __func__);
         }
     }
 
     CBlockLocator locator;
     if (!block_tree_db.Read(DB_TXINDEX_BLOCK, locator)) {
         return true;
     }
 
     int64_t count = 0;
     LogPrintf("Upgrading txindex database... [0%%]\n");
     uiInterface.ShowProgress(_("Upgrading txindex database"), 0, true);
     int report_done = 0;
     const size_t batch_size = 1 << 24; // 16 MiB
 
     CDBBatch batch_newdb(*this);
     CDBBatch batch_olddb(block_tree_db);
 
     std::pair<unsigned char, uint256> key;
     std::pair<unsigned char, uint256> begin_key{DB_TXINDEX, uint256()};
     std::pair<unsigned char, uint256> prev_key = begin_key;
 
     bool interrupted = false;
     std::unique_ptr<CDBIterator> cursor(block_tree_db.NewIterator());
     for (cursor->Seek(begin_key); cursor->Valid(); cursor->Next()) {
         boost::this_thread::interruption_point();
         if (ShutdownRequested()) {
             interrupted = true;
             break;
         }
 
         if (!cursor->GetKey(key)) {
             return error("%s: cannot get key from valid cursor", __func__);
         }
         if (key.first != DB_TXINDEX) {
             break;
         }
 
         // Log progress every 10%.
         if (++count % 256 == 0) {
             // Since txids are uniformly random and traversed in increasing
             // order, the high 16 bits of the hash can be used to estimate the
             // current progress.
             const uint256 &txid = key.second;
             uint32_t high_nibble =
                 (static_cast<uint32_t>(*(txid.begin() + 0)) << 8) +
                 (static_cast<uint32_t>(*(txid.begin() + 1)) << 0);
             int percentage_done = (int)(high_nibble * 100.0 / 65536.0 + 0.5);
 
             uiInterface.ShowProgress(_("Upgrading txindex database"),
                                      percentage_done, true);
             if (report_done < percentage_done / 10) {
                 LogPrintf("Upgrading txindex database... [%d%%]\n",
                           percentage_done);
                 report_done = percentage_done / 10;
             }
         }
 
         CDiskTxPos value;
         if (!cursor->GetValue(value)) {
             return error("%s: cannot parse txindex record", __func__);
         }
         batch_newdb.Write(key, value);
         batch_olddb.Erase(key);
 
         if (batch_newdb.SizeEstimate() > batch_size ||
             batch_olddb.SizeEstimate() > batch_size) {
             // NOTE: it's OK to delete the key pointed at by the current DB
             // cursor while iterating because LevelDB iterators are guaranteed
             // to provide a consistent view of the underlying data, like a
             // lightweight snapshot.
             WriteTxIndexMigrationBatches(*this, block_tree_db, batch_newdb,
                                          batch_olddb, prev_key, key);
             prev_key = key;
         }
     }
 
     // If these final DB batches complete the migration, write the best block
     // hash marker to the new database and delete from the old one. This signals
     // that the former is fully caught up to that point in the blockchain and
     // that all txindex entries have been removed from the latter.
     if (!interrupted) {
         batch_olddb.Erase(DB_TXINDEX_BLOCK);
         batch_newdb.Write(DB_BEST_BLOCK, locator);
     }
 
     WriteTxIndexMigrationBatches(*this, block_tree_db, batch_newdb, batch_olddb,
                                  begin_key, key);
 
     if (interrupted) {
         LogPrintf("[CANCELLED].\n");
         return false;
     }
 
     uiInterface.ShowProgress("", 100, false);
 
     LogPrintf("[DONE].\n");
     return true;
 }
diff --git a/src/undo.h b/src/undo.h
index 62e99d080..4406b339d 100644
--- a/src/undo.h
+++ b/src/undo.h
@@ -1,145 +1,145 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_UNDO_H
 #define BITCOIN_UNDO_H
 
 #include <coins.h>
 #include <compressor.h>
 #include <consensus/consensus.h>
 #include <serialize.h>
 #include <version.h>
 
 class CBlock;
 class CBlockIndex;
 class CCoinsViewCache;
 class CValidationState;
 
 /**
  * Undo information for a CTxIn
  *
  * Contains the prevout's CTxOut being spent, and its metadata as well (coinbase
  * or not, height). The serialization contains a dummy value of zero. This is be
  * compatible with older versions which expect to see the transaction version
  * there.
  */
 class TxInUndoSerializer {
     const Coin *pcoin;
 
 public:
     explicit TxInUndoSerializer(const Coin *pcoinIn) : pcoin(pcoinIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         ::Serialize(
             s, VARINT(pcoin->GetHeight() * 2 + (pcoin->IsCoinBase() ? 1 : 0)));
         if (pcoin->GetHeight() > 0) {
             // Required to maintain compatibility with older undo format.
             ::Serialize(s, uint8_t(0));
         }
         ::Serialize(s, CTxOutCompressor(REF(pcoin->GetTxOut())));
     }
 };
 
 class TxInUndoDeserializer {
     Coin *pcoin;
 
 public:
     explicit TxInUndoDeserializer(Coin *pcoinIn) : pcoin(pcoinIn) {}
 
     template <typename Stream> void Unserialize(Stream &s) {
         uint32_t nCode = 0;
         ::Unserialize(s, VARINT(nCode));
         uint32_t nHeight = nCode / 2;
         bool fCoinBase = nCode & 1;
         if (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));
         }
 
         CTxOut txout;
-        ::Unserialize(s, REF(CTxOutCompressor(REF(txout))));
+        ::Unserialize(s, CTxOutCompressor(REF(txout)));
 
         *pcoin = Coin(std::move(txout), nHeight, fCoinBase);
     }
 };
 
 static const size_t MAX_INPUTS_PER_TX =
     MAX_TX_SIZE / ::GetSerializeSize(CTxIn(), SER_NETWORK, PROTOCOL_VERSION);
 
 /** Restore the UTXO in a Coin at a given COutPoint */
 class CTxUndo {
 public:
     // 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)));
+            ::Serialize(s, 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_TX) {
             throw std::ios_base::failure("Too many input undo records");
         }
         vprevout.resize(count);
         for (auto &prevout : vprevout) {
-            ::Unserialize(s, REF(TxInUndoDeserializer(&prevout)));
+            ::Unserialize(s, TxInUndoDeserializer(&prevout));
         }
     }
 };
 
 /** Undo information for a CBlock */
 class CBlockUndo {
 public:
     // For all but the coinbase
     std::vector<CTxUndo> vtxundo;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vtxundo);
     }
 };
 
 enum DisconnectResult {
     // All good.
     DISCONNECT_OK,
     // Rolled back, but UTXO set was inconsistent with block.
     DISCONNECT_UNCLEAN,
     // Something else went wrong.
     DISCONNECT_FAILED,
 };
 
 /**
  * Restore the UTXO in a Coin at a given COutPoint.
  * @param undo The Coin to be restored.
  * @param view The coins view to which to apply the changes.
  * @param out The out point that corresponds to the tx input.
  * @return A DisconnectResult
  */
 DisconnectResult UndoCoinSpend(const Coin &undo, CCoinsViewCache &view,
                                const COutPoint &out);
 
 /**
  * Undo a block from the block and the undoblock data.
  * See DisconnectBlock for more details.
  */
 DisconnectResult ApplyBlockUndo(const CBlockUndo &blockUndo,
                                 const CBlock &block, const CBlockIndex *pindex,
                                 CCoinsViewCache &coins);
 
 #endif // BITCOIN_UNDO_H