diff --git a/src/coins.cpp b/src/coins.cpp
index c28e2ba908..3e8499ce41 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -1,387 +1,382 @@
 // Copyright (c) 2012-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include "coins.h"
 
 #include "consensus/consensus.h"
 #include "memusage.h"
 #include "random.h"
 
 #include <cassert>
 
 /**
  * calculate number of bytes for the bitmask, and its number of non-zero bytes
  * each bit in the bitmask represents the availability of one output, but the
  * availabilities of the first two outputs are encoded separately
  */
 void CCoins::CalcMaskSize(unsigned int &nBytes,
                           unsigned int &nNonzeroBytes) const {
     unsigned int nLastUsedByte = 0;
     for (unsigned int b = 0; 2 + b * 8 < vout.size(); b++) {
         bool fZero = true;
         for (unsigned int i = 0; i < 8 && 2 + b * 8 + i < vout.size(); i++) {
             if (!vout[2 + b * 8 + i].IsNull()) {
                 fZero = false;
                 continue;
             }
         }
         if (!fZero) {
             nLastUsedByte = b + 1;
             nNonzeroBytes++;
         }
     }
     nBytes += nLastUsedByte;
 }
 
 bool CCoins::Spend(uint32_t nPos) {
     if (nPos >= vout.size() || vout[nPos].IsNull()) return false;
     vout[nPos].SetNull();
     Cleanup();
     return true;
 }
 
 bool CCoinsView::GetCoins(const uint256 &txid, CCoins &coins) const {
     return false;
 }
 bool CCoinsView::HaveCoins(const uint256 &txid) const {
     return false;
 }
 uint256 CCoinsView::GetBestBlock() const {
     return uint256();
 }
 bool CCoinsView::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
     return false;
 }
 CCoinsViewCursor *CCoinsView::Cursor() const {
     return 0;
 }
 
 CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) {}
 bool CCoinsViewBacked::GetCoins(const uint256 &txid, CCoins &coins) const {
     return base->GetCoins_DONOTUSE(txid, coins);
 }
 bool CCoinsViewBacked::HaveCoins(const uint256 &txid) const {
     return base->HaveCoins_DONOTUSE(txid);
 }
 uint256 CCoinsViewBacked::GetBestBlock() const {
     return base->GetBestBlock();
 }
 void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) {
     base = &viewIn;
 }
 bool CCoinsViewBacked::BatchWrite(CCoinsMap &mapCoins,
                                   const uint256 &hashBlock) {
     return base->BatchWrite(mapCoins, hashBlock);
 }
 CCoinsViewCursor *CCoinsViewBacked::Cursor() const {
     return base->Cursor();
 }
 
 SaltedTxidHasher::SaltedTxidHasher()
     : k0(GetRand(std::numeric_limits<uint64_t>::max())),
       k1(GetRand(std::numeric_limits<uint64_t>::max())) {}
 
 CCoinsViewCache::CCoinsViewCache(CCoinsView *baseIn)
-    : CCoinsViewBacked(baseIn), hasModifier(false), cachedCoinsUsage(0) {}
-
-CCoinsViewCache::~CCoinsViewCache() {
-    assert(!hasModifier);
-}
+    : CCoinsViewBacked(baseIn), cachedCoinsUsage(0) {}
 
 size_t CCoinsViewCache::DynamicMemoryUsage() const {
     return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
 }
 
 CCoinsMap::iterator CCoinsViewCache::FetchCoins(const uint256 &txid) const {
     CCoinsMap::iterator it = cacheCoins.find(txid);
     if (it != cacheCoins.end()) {
         return it;
     }
     CCoins tmp;
     if (!base->GetCoins_DONOTUSE(txid, tmp)) {
         return cacheCoins.end();
     }
     CCoinsMap::iterator ret =
         cacheCoins.insert(std::make_pair(txid, CCoinsCacheEntry())).first;
     tmp.swap(ret->second.coins);
     if (ret->second.coins.IsPruned()) {
         // The parent only has an empty entry for this txid; we can consider our
         // version as fresh.
         ret->second.flags = CCoinsCacheEntry::FRESH;
     }
     cachedCoinsUsage += ret->second.coins.DynamicMemoryUsage();
     return ret;
 }
 
 bool CCoinsViewCache::GetCoins(const uint256 &txid, CCoins &coins) const {
     CCoinsMap::const_iterator it = FetchCoins(txid);
     if (it != cacheCoins.end()) {
         coins = it->second.coins;
         return true;
     }
     return false;
 }
 
 void CCoinsViewCache::AddCoin(const COutPoint &outpoint, const Coin &coin,
                               bool possible_overwrite) {
     assert(!coin.IsSpent());
     if (coin.GetTxOut().scriptPubKey.IsUnspendable()) {
         return;
     }
     CCoinsMap::iterator it;
     bool inserted;
     std::tie(it, inserted) = cacheCoins.emplace(
         std::piecewise_construct, std::forward_as_tuple(outpoint.hash),
         std::tuple<>());
     bool fresh = false;
     if (!inserted) {
         cachedCoinsUsage -= it->second.coins.DynamicMemoryUsage();
     }
     if (!possible_overwrite) {
         if (it->second.coins.IsAvailable(outpoint.n)) {
             throw std::logic_error(
                 "Adding new coin that replaces non-pruned entry");
         }
         fresh = it->second.coins.IsPruned() &&
                 !(it->second.flags & CCoinsCacheEntry::DIRTY);
     }
     if (it->second.coins.vout.size() <= outpoint.n) {
         it->second.coins.vout.resize(outpoint.n + 1);
     }
     it->second.coins.vout[outpoint.n] = coin.GetTxOut();
     it->second.coins.nHeight = coin.GetHeight();
     it->second.coins.fCoinBase = coin.IsCoinBase();
     it->second.flags |=
         CCoinsCacheEntry::DIRTY | (fresh ? CCoinsCacheEntry::FRESH : 0);
     cachedCoinsUsage += it->second.coins.DynamicMemoryUsage();
 }
 
 void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight) {
     bool fCoinbase = tx.IsCoinBase();
     const uint256 &txid = tx.GetHash();
     for (size_t i = 0; i < tx.vout.size(); ++i) {
         // Pass fCoinbase as the possible_overwrite flag to AddCoin, in order to
         // correctly deal with the pre-BIP30 occurrances of duplicate coinbase
         // transactions.
         cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase),
                       fCoinbase);
     }
 }
 
 bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin *moveout) {
     CCoinsMap::iterator it = FetchCoins(outpoint.hash);
     if (it == cacheCoins.end()) {
         return false;
     }
     cachedCoinsUsage -= it->second.coins.DynamicMemoryUsage();
     if (moveout && it->second.coins.IsAvailable(outpoint.n)) {
         *moveout = Coin(it->second.coins.vout[outpoint.n],
                         it->second.coins.nHeight, it->second.coins.fCoinBase);
     }
     // Ignore return value: SpendCoin has no effect if no UTXO found.
     it->second.coins.Spend(outpoint.n);
     if (it->second.coins.IsPruned() &&
         it->second.flags & CCoinsCacheEntry::FRESH) {
         cacheCoins.erase(it);
     } else {
         cachedCoinsUsage += it->second.coins.DynamicMemoryUsage();
         it->second.flags |= CCoinsCacheEntry::DIRTY;
     }
     return true;
 }
 
 const CCoins *CCoinsViewCache::AccessCoins(const uint256 &txid) const {
     CCoinsMap::const_iterator it = FetchCoins(txid);
     if (it == cacheCoins.end()) {
         return nullptr;
     }
 
     return &it->second.coins;
 }
 
 static const Coin coinEmpty;
 
 const Coin CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = FetchCoins(outpoint.hash);
     if (it == cacheCoins.end() || !it->second.coins.IsAvailable(outpoint.n)) {
         return coinEmpty;
     }
     return Coin(it->second.coins.vout[outpoint.n], it->second.coins.nHeight,
                 it->second.coins.fCoinBase);
 }
 
 bool CCoinsViewCache::HaveCoins(const uint256 &txid) const {
     CCoinsMap::const_iterator it = FetchCoins(txid);
     // We're using vtx.empty() instead of IsPruned here for performance reasons,
     // as we only care about the case where a transaction was replaced entirely
     // in a reorganization (which wipes vout entirely, as opposed to spending
     // which just cleans individual outputs).
     return (it != cacheCoins.end() && !it->second.coins.vout.empty());
 }
 
 bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = cacheCoins.find(outpoint.hash);
     return it != cacheCoins.end() && it->second.coins.IsAvailable(outpoint.n);
 }
 
 uint256 CCoinsViewCache::GetBestBlock() const {
     if (hashBlock.IsNull()) hashBlock = base->GetBestBlock();
     return hashBlock;
 }
 
 void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
     hashBlock = hashBlockIn;
 }
 
 bool CCoinsViewCache::BatchWrite(CCoinsMap &mapCoins,
                                  const uint256 &hashBlockIn) {
-    assert(!hasModifier);
     for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
         // Ignore non-dirty entries (optimization).
         if (it->second.flags & CCoinsCacheEntry::DIRTY) {
             CCoinsMap::iterator itUs = cacheCoins.find(it->first);
             if (itUs == cacheCoins.end()) {
                 // The parent cache does not have an entry, while the child does
                 // We can ignore it if it's both FRESH and pruned in the child
                 if (!(it->second.flags & CCoinsCacheEntry::FRESH &&
                       it->second.coins.IsPruned())) {
                     // Otherwise we will need to create it in the parent and
                     // move the data up and mark it as dirty
                     CCoinsCacheEntry &entry = cacheCoins[it->first];
                     entry.coins.swap(it->second.coins);
                     cachedCoinsUsage += entry.coins.DynamicMemoryUsage();
                     entry.flags = CCoinsCacheEntry::DIRTY;
                     // We can mark it FRESH in the parent if it was FRESH in the
                     // child. Otherwise it might have just been flushed from the
                     // parent's cache and already exist in the grandparent
                     if (it->second.flags & CCoinsCacheEntry::FRESH)
                         entry.flags |= CCoinsCacheEntry::FRESH;
                 }
             } else {
                 // Assert that the child cache entry was not marked FRESH if the
                 // parent cache entry has unspent outputs. If this ever happens,
                 // it means the FRESH flag was misapplied and there is a logic
                 // error in the calling code.
                 if ((it->second.flags & CCoinsCacheEntry::FRESH) &&
                     !itUs->second.coins.IsPruned())
                     throw std::logic_error("FRESH flag misapplied to cache "
                                            "entry for base transaction with "
                                            "spendable outputs");
 
                 // Found the entry in the parent cache
                 if ((itUs->second.flags & CCoinsCacheEntry::FRESH) &&
                     it->second.coins.IsPruned()) {
                     // The grandparent does not have an entry, and the child is
                     // modified and being pruned. This means we can just delete
                     // it from the parent.
                     cachedCoinsUsage -= itUs->second.coins.DynamicMemoryUsage();
                     cacheCoins.erase(itUs);
                 } else {
                     // A normal modification.
                     cachedCoinsUsage -= itUs->second.coins.DynamicMemoryUsage();
                     itUs->second.coins.swap(it->second.coins);
                     cachedCoinsUsage += itUs->second.coins.DynamicMemoryUsage();
                     itUs->second.flags |= CCoinsCacheEntry::DIRTY;
                     // NOTE: It is possible the child has a FRESH flag here in
                     // the event the entry we found in the parent is pruned. But
                     // we must not copy that FRESH flag to the parent as that
                     // pruned state likely still needs to be communicated to the
                     // grandparent.
                 }
             }
         }
         CCoinsMap::iterator itOld = it++;
         mapCoins.erase(itOld);
     }
     hashBlock = hashBlockIn;
     return true;
 }
 
 bool CCoinsViewCache::Flush() {
     bool fOk = base->BatchWrite(cacheCoins, hashBlock);
     cacheCoins.clear();
     cachedCoinsUsage = 0;
     return fOk;
 }
 
 void CCoinsViewCache::Uncache(const COutPoint &outpoint) {
     CCoinsMap::iterator it = cacheCoins.find(outpoint.hash);
     if (it != cacheCoins.end() && it->second.flags == 0) {
         cachedCoinsUsage -= it->second.coins.DynamicMemoryUsage();
         cacheCoins.erase(it);
     }
 }
 
 unsigned int CCoinsViewCache::GetCacheSize() const {
     return cacheCoins.size();
 }
 
 const CTxOut &CCoinsViewCache::GetOutputFor(const CTxIn &input) const {
     const CCoins *coins = AccessCoins(input.prevout.hash);
     assert(coins && coins->IsAvailable(input.prevout.n));
     return coins->vout[input.prevout.n];
 }
 
 CAmount CCoinsViewCache::GetValueIn(const CTransaction &tx) const {
     if (tx.IsCoinBase()) return 0;
 
     CAmount nResult = 0;
     for (unsigned int i = 0; i < tx.vin.size(); i++)
         nResult += GetOutputFor(tx.vin[i]).nValue;
 
     return nResult;
 }
 
 bool CCoinsViewCache::HaveInputs(const CTransaction &tx) const {
     if (tx.IsCoinBase()) {
         return true;
     }
 
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
         const COutPoint &prevout = tx.vin[i].prevout;
         const CCoins *coins = AccessCoins(prevout.hash);
         if (!coins || !coins->IsAvailable(prevout.n)) {
             return false;
         }
     }
 
     return true;
 }
 
 double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight,
                                     CAmount &inChainInputValue) const {
     inChainInputValue = 0;
     if (tx.IsCoinBase()) return 0.0;
     double dResult = 0.0;
     for (const CTxIn &txin : tx.vin) {
         const CCoins *coins = AccessCoins(txin.prevout.hash);
         assert(coins);
         if (!coins->IsAvailable(txin.prevout.n)) continue;
         if (coins->nHeight <= nHeight) {
             dResult += (double)(coins->vout[txin.prevout.n].nValue) *
                        (nHeight - coins->nHeight);
             inChainInputValue += coins->vout[txin.prevout.n].nValue;
         }
     }
     return tx.ComputePriority(dResult);
 }
 
 CCoinsViewCursor::~CCoinsViewCursor() {}
 
 // TODO: merge with similar definition in undo.h.
 static const size_t MAX_OUTPUTS_PER_TX =
     MAX_TX_SIZE / ::GetSerializeSize(CTxOut(), SER_NETWORK, PROTOCOL_VERSION);
 
 const Coin AccessByTxid(const CCoinsViewCache &view, const uint256 &txid) {
     COutPoint iter(txid, 0);
     while (iter.n < MAX_OUTPUTS_PER_TX) {
         const Coin &alternate = view.AccessCoin(iter);
         if (!alternate.IsSpent()) {
             return alternate;
         }
         ++iter.n;
     }
 
     return coinEmpty;
 }
diff --git a/src/coins.h b/src/coins.h
index 907b75b284..68426e6bfe 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -1,575 +1,571 @@
 // 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 "hash.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)));
     }
 
     size_t DynamicMemoryUsage() const {
         return memusage::DynamicUsage(out.scriptPubKey);
     }
 };
 
 /**
  * Pruned version of CTransaction: only retains metadata and unspent transaction outputs
  *
  * Serialized format:
  * - VARINT(nVersion) - DEPRECATED, always zero on new reccords.
  * - VARINT(nCode)
  * - unspentness bitvector, for vout[2] and further; least significant byte first
  * - the non-spent CTxOuts (via CTxOutCompressor)
  * - VARINT(nHeight)
  *
  * The nCode value consists of:
  * - bit 0: IsCoinBase()
  * - bit 1: vout[0] is not spent
  * - bit 2: vout[1] is not spent
  * - The higher bits encode N, the number of non-zero bytes in the following bitvector.
  *   - In case both bit 1 and bit 2 are unset, they encode N-1, as there must be at
  *     least one non-spent output).
  *
  * Example: 0104835800816115944e077fe7c803cfa57f29b36bf87c1d358bb85e
  *          <><><--------------------------------------------><---->
  *          |  \                  |                             /
  *    version   code             vout[1]                  height
  *
  *    - version = 1
  *    - code = 4 (vout[1] is not spent, and 0 non-zero bytes of bitvector follow)
  *    - unspentness bitvector: as 0 non-zero bytes follow, it has length 0
  *    - vout[1]: 835800816115944e077fe7c803cfa57f29b36bf87c1d35
  *               * 8358: compact amount representation for 60000000000 (600 BCC)
  *               * 00: special txout type pay-to-pubkey-hash
  *               * 816115944e077fe7c803cfa57f29b36bf87c1d35: address uint160
  *    - height = 203998
  *
  *
  * Example: 0109044086ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4eebbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa486af3b
  *          <><><--><--------------------------------------------------><----------------------------------------------><---->
  *         /  \   \                     |                                                           |                     /
  *  version  code  unspentness       vout[4]                                                     vout[16]           height
  *
  *  - version = 1
  *  - code = 9 (coinbase, neither vout[0] or vout[1] are unspent,
  *                2 (1, +1 because both bit 1 and bit 2 are unset) non-zero bitvector bytes follow)
  *  - unspentness bitvector: bits 2 (0x04) and 14 (0x4000) are set, so vout[2+2] and vout[14+2] are unspent
  *  - vout[4]: 86ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4ee
  *             * 86ef97d579: compact amount representation for 234925952 (2.35 BCC)
  *             * 00: special txout type pay-to-pubkey-hash
  *             * 61b01caab50f1b8e9c50a5057eb43c2d9563a4ee: address uint160
  *  - vout[16]: bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4
  *              * bbd123: compact amount representation for 110397 (0.001 BCC)
  *              * 00: special txout type pay-to-pubkey-hash
  *              * 8c988f1a4a4de2161e0f50aac7f17e7f9555caa4: address uint160
  *  - height = 120891
  *
  * @DISABLE FORMATING FOR THIS COMMENT@
  */
 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;
 
     void FromTx(const CTransaction &tx, int nHeightIn) {
         fCoinBase = tx.IsCoinBase();
         vout = tx.vout;
         nHeight = nHeightIn;
         ClearUnspendable();
     }
 
     //! construct a CCoins from a CTransaction, at a given height
     CCoins(const CTransaction &tx, int nHeightIn) { FromTx(tx, nHeightIn); }
 
     void Clear() {
         fCoinBase = false;
         std::vector<CTxOut>().swap(vout);
         nHeight = 0;
     }
 
     //! empty constructor
     CCoins() : fCoinBase(false), vout(0), nHeight(0) {}
 
     //! remove spent outputs at the end of vout
     void Cleanup() {
         while (vout.size() > 0 && vout.back().IsNull()) {
             vout.pop_back();
         }
 
         if (vout.empty()) {
             std::vector<CTxOut>().swap(vout);
         }
     }
 
     void ClearUnspendable() {
         for (CTxOut &txout : vout) {
             if (txout.scriptPubKey.IsUnspendable()) {
                 txout.SetNull();
             }
         }
 
         Cleanup();
     }
 
     void swap(CCoins &to) {
         std::swap(to.fCoinBase, fCoinBase);
         to.vout.swap(vout);
         std::swap(to.nHeight, nHeight);
     }
 
     //! equality test
     friend bool operator==(const CCoins &a, const CCoins &b) {
         // Empty CCoins objects are always equal.
         if (a.IsPruned() && b.IsPruned()) {
             return true;
         }
 
         return a.fCoinBase == b.fCoinBase && a.nHeight == b.nHeight &&
                a.vout == b.vout;
     }
 
     friend bool operator!=(const CCoins &a, const CCoins &b) {
         return !(a == b);
     }
 
     void CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const;
 
     bool IsCoinBase() const { return fCoinBase; }
 
     template <typename Stream> void Serialize(Stream &s) const {
         unsigned int nMaskSize = 0, nMaskCode = 0;
         CalcMaskSize(nMaskSize, nMaskCode);
         bool fFirst = vout.size() > 0 && !vout[0].IsNull();
         bool fSecond = vout.size() > 1 && !vout[1].IsNull();
         assert(fFirst || fSecond || nMaskCode);
         unsigned int nCode = 8 * (nMaskCode - (fFirst || fSecond ? 0 : 1)) +
                              (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) +
                              (fSecond ? 4 : 0);
         // version
         int nVersionDummy = 0;
         ::Serialize(s, VARINT(nVersionDummy));
         // header code
         ::Serialize(s, VARINT(nCode));
         // spentness bitmask
         for (unsigned int b = 0; b < nMaskSize; b++) {
             uint8_t chAvail = 0;
             for (size_t i = 0; i < 8 && 2 + b * 8 + i < vout.size(); i++) {
                 if (!vout[2 + b * 8 + i].IsNull()) {
                     chAvail |= (1 << i);
                 }
             }
             ::Serialize(s, chAvail);
         }
         // txouts themself
         for (unsigned int i = 0; i < vout.size(); i++) {
             if (!vout[i].IsNull()) {
                 ::Serialize(s, CTxOutCompressor(REF(vout[i])));
             }
         }
         // coinbase height
         ::Serialize(s, VARINT(nHeight));
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int 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;
         unsigned int 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 (unsigned int i = 0; i < vAvail.size(); i++) {
             if (vAvail[i]) {
                 ::Unserialize(s, REF(CTxOutCompressor(vout[i])));
             }
         }
         // coinbase height
         ::Unserialize(s, VARINT(nHeight));
         Cleanup();
     }
 
     //! mark a vout spent
     bool Spend(uint32_t nPos);
 
     //! check whether a particular output is still available
     bool IsAvailable(unsigned int nPos) const {
         return (nPos < vout.size() && !vout[nPos].IsNull());
     }
 
     //! check whether the entire CCoins is spent
     //! note that only !IsPruned() CCoins can be serialized
     bool IsPruned() const {
         for (const CTxOut &out : vout) {
             if (!out.IsNull()) {
                 return false;
             }
         }
         return true;
     }
 
     size_t DynamicMemoryUsage() const {
         size_t ret = memusage::DynamicUsage(vout);
         for (const CTxOut &out : vout) {
             ret += RecursiveDynamicUsage(out.scriptPubKey);
         }
         return ret;
     }
 };
 
 class SaltedTxidHasher {
 private:
     /** Salt */
     const uint64_t k0, k1;
 
 public:
     SaltedTxidHasher();
 
     /**
      * 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 uint256 &txid) const {
         return SipHashUint256(k0, k1, txid);
     }
 };
 
 struct CCoinsCacheEntry {
     CCoins coins; // The actual cached data.
     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() : coins(), flags(0) {}
 };
 
 typedef std::unordered_map<uint256, CCoinsCacheEntry, SaltedTxidHasher>
     CCoinsMap;
 
 /** Cursor for iterating over CoinsView state */
 class CCoinsViewCursor {
 public:
     CCoinsViewCursor(const uint256 &hashBlockIn) : hashBlock(hashBlockIn) {}
     virtual ~CCoinsViewCursor();
 
     virtual bool GetKey(uint256 &key) const = 0;
     virtual bool GetValue(CCoins &coins) const = 0;
     /* Don't care about GetKeySize here */
     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 {
 protected:
     //! Retrieve the CCoins (unspent transaction outputs) for a given txid
     virtual bool GetCoins(const uint256 &txid, CCoins &coins) const;
 
     //! Just check whether we have data for a given txid.
     //! This may (but cannot always) return true for fully spent transactions
     virtual bool HaveCoins(const uint256 &txid) const;
 
 public:
     //! Transitional function to move from GetCoins to GetCoin.
     bool GetCoins_DONOTUSE(const uint256 &txid, CCoins &coins) const {
         return GetCoins(txid, coins);
     }
 
     //! Retrieve the Coin (unspent transaction output) for a given outpoint.
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const {
         CCoins coins;
         if (!GetCoins(outpoint.hash, coins) || !coins.IsAvailable(outpoint.n)) {
             return false;
         }
 
         coin = Coin(coins.vout[outpoint.n], coins.nHeight, coins.fCoinBase);
         return true;
     }
 
     //! Transitional function to move from HaveCoins to HaveCoin.
     bool HaveCoins_DONOTUSE(const uint256 &txid) const {
         return HaveCoins(txid);
     }
 
     //! Just check whether we have data for a given outpoint.
     //! This may (but cannot always) return true for spent outputs.
     bool HaveCoin(const COutPoint &outpoint) const {
         CCoins coins;
         if (!GetCoins(outpoint.hash, coins)) {
             return false;
         }
         return coins.IsAvailable(outpoint.n);
     }
 
     //! Retrieve the block hash whose state this CCoinsView currently represents
     virtual uint256 GetBestBlock() const;
 
     //! Do a bulk modification (multiple CCoins 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() {}
 };
 
 /** CCoinsView backed by another CCoinsView */
 class CCoinsViewBacked : public CCoinsView {
 protected:
     CCoinsView *base;
 
     bool GetCoins(const uint256 &txid, CCoins &coins) const;
     bool HaveCoins(const uint256 &txid) const;
 
 public:
     CCoinsViewBacked(CCoinsView *viewIn);
     uint256 GetBestBlock() const;
     void SetBackend(CCoinsView &viewIn);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock);
     CCoinsViewCursor *Cursor() const;
 };
 
 /**
  * CCoinsView that adds a memory cache for transactions to another CCoinsView
  */
 class CCoinsViewCache : public CCoinsViewBacked {
 protected:
-    /* Whether this cache has an active modifier. */
-    bool hasModifier;
-
     /**
      * 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 CCoins objects. */
     mutable size_t cachedCoinsUsage;
 
     bool GetCoins(const uint256 &txid, CCoins &coins) const;
     bool HaveCoins(const uint256 &txid) const;
 
     /**
      * Return a pointer to CCoins in the cache, or nullptr if not found. This is
      * more efficient than GetCoins. Modifications to other cache entries are
      * allowed while accessing the returned pointer.
      */
     const CCoins *AccessCoins(const uint256 &txid) const;
 
 public:
     CCoinsViewCache(CCoinsView *baseIn);
-    ~CCoinsViewCache();
 
     // Standard CCoinsView methods
     uint256 GetBestBlock() const;
     void SetBestBlock(const uint256 &hashBlock);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock);
 
     /**
      * 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;
 
     //! Transitional function to move from AccessCoins to AccessCoin.
     const CCoins *AccessCoins_DONOTUSE(const uint256 &txid) const {
         return AccessCoins(txid);
     }
 
     /**
      * Return a copy of 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.
      * TODO: return a reference instead of a value once underlying storage is
      * updated.
      */
     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, const 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 transactions)
     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)
      */
     CAmount 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,
                        CAmount &inChainInputValue) const;
 
     const CTxOut &GetOutputFor(const CTxIn &input) const;
 
     friend class CCoinsModifier;
 
 private:
     CCoinsMap::iterator FetchCoins(const uint256 &txid) 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.
 // It assumes that overwrites are only possible for coinbase transactions.
 // TODO: pass in a boolean to limit these possible overwrites to known
 // (pre-BIP34) cases.
 void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight);
 
 //! Utility function to find any unspent output with a given txid.
 const Coin AccessByTxid(const CCoinsViewCache &cache, const uint256 &txid);
 
 #endif // BITCOIN_COINS_H