diff --git a/src/miner.cpp b/src/miner.cpp
index ea3dd55e9..0a634dff9 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -1,714 +1,715 @@
 // 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 <miner.h>
 
 #include <amount.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <hash.h>
 #include <net.h>
 #include <policy/policy.h>
 #include <pow.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <timedata.h>
 #include <txmempool.h>
 #include <util.h>
 #include <utilmoneystr.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <algorithm>
 #include <queue>
 #include <utility>
 
 // Unconfirmed transactions in the memory pool often depend on other
 // transactions in the memory pool. When we select transactions from the
 // pool, we select by highest priority or fee rate, so we might consider
 // transactions that depend on transactions that aren't yet in the block.
 
 uint64_t nLastBlockTx = 0;
 uint64_t nLastBlockSize = 0;
 
 int64_t UpdateTime(CBlockHeader *pblock, const Config &config,
                    const CBlockIndex *pindexPrev) {
     int64_t nOldTime = pblock->nTime;
     int64_t nNewTime =
         std::max(pindexPrev->GetMedianTimePast() + 1, GetAdjustedTime());
 
     if (nOldTime < nNewTime) {
         pblock->nTime = nNewTime;
     }
 
     const Consensus::Params &consensusParams =
         config.GetChainParams().GetConsensus();
 
     // Updating time can change work required on testnet:
     if (consensusParams.fPowAllowMinDifficultyBlocks) {
         pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, config);
     }
 
     return nNewTime - nOldTime;
 }
 
 static uint64_t ComputeMaxGeneratedBlockSize(const Config &config,
                                              const CBlockIndex *pindexPrev) {
     // Block resource limits
     // If -blockmaxsize is not given, limit to DEFAULT_MAX_GENERATED_BLOCK_SIZE
     // If only one is given, only restrict the specified resource.
     // If both are given, restrict both.
     uint64_t nMaxGeneratedBlockSize = DEFAULT_MAX_GENERATED_BLOCK_SIZE;
     if (gArgs.IsArgSet("-blockmaxsize")) {
         nMaxGeneratedBlockSize =
             gArgs.GetArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     }
 
     // Limit size to between 1K and MaxBlockSize-1K for sanity:
     nMaxGeneratedBlockSize =
         std::max(uint64_t(1000), std::min(config.GetMaxBlockSize() - 1000,
                                           nMaxGeneratedBlockSize));
 
     return nMaxGeneratedBlockSize;
 }
 
 BlockAssembler::BlockAssembler(const Config &_config, const CTxMemPool &mpool)
     : config(&_config), mempool(&mpool) {
 
     if (gArgs.IsArgSet("-blockmintxfee")) {
         Amount n = Amount::zero();
         ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n);
         blockMinFeeRate = CFeeRate(n);
     } else {
         blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB);
     }
 
     LOCK(cs_main);
     nMaxGeneratedBlockSize =
         ComputeMaxGeneratedBlockSize(*config, chainActive.Tip());
 }
 
 void BlockAssembler::resetBlock() {
     inBlock.clear();
 
     // Reserve space for coinbase tx.
     nBlockSize = 1000;
     nBlockSigOps = 100;
 
     // These counters do not include coinbase tx.
     nBlockTx = 0;
     nFees = Amount::zero();
 
     lastFewTxs = 0;
 }
 
 static const std::vector<uint8_t>
 getExcessiveBlockSizeSig(const Config &config) {
     std::string cbmsg = "/EB" + getSubVersionEB(config.GetMaxBlockSize()) + "/";
     const char *cbcstr = cbmsg.c_str();
     std::vector<uint8_t> vec(cbcstr, cbcstr + cbmsg.size());
     return vec;
 }
 
 std::unique_ptr<CBlockTemplate>
 BlockAssembler::CreateNewBlock(const CScript &scriptPubKeyIn) {
     int64_t nTimeStart = GetTimeMicros();
 
     resetBlock();
 
     pblocktemplate.reset(new CBlockTemplate());
     if (!pblocktemplate.get()) {
         return nullptr;
     }
 
     // Pointer for convenience.
     pblock = &pblocktemplate->block;
 
     // Add dummy coinbase tx as first transaction.  It is updated at the end.
     pblocktemplate->entries.emplace_back(CTransactionRef(), -SATOSHI, 0, -1);
 
     LOCK2(cs_main, mempool->cs);
     CBlockIndex *pindexPrev = chainActive.Tip();
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
 
     const CChainParams &chainparams = config->GetChainParams();
     pblock->nVersion =
         ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // -regtest only: allow overriding block.nVersion with
     // -blockversion=N to test forking scenarios
     if (chainparams.MineBlocksOnDemand()) {
         pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
     }
 
     pblock->nTime = GetAdjustedTime();
     nMaxGeneratedBlockSize = ComputeMaxGeneratedBlockSize(*config, pindexPrev);
 
     nMedianTimePast = pindexPrev->GetMedianTimePast();
     nLockTimeCutoff =
         (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST)
             ? nMedianTimePast
             : pblock->GetBlockTime();
 
     addPriorityTxs();
     int nPackagesSelected = 0;
     int nDescendantsUpdated = 0;
     addPackageTxs(nPackagesSelected, nDescendantsUpdated);
 
     if (IsMagneticAnomalyEnabled(*config, pindexPrev)) {
         // If magnetic anomaly is enabled, we make sure transaction are
         // canonically ordered.
         // FIXME: Use a zipped list. See T479
         std::sort(std::begin(pblocktemplate->entries) + 1,
                   std::end(pblocktemplate->entries),
                   [](const CBlockTemplateEntry &a, const CBlockTemplateEntry &b)
                       -> bool { return a.tx->GetId() < b.tx->GetId(); });
     }
 
     int64_t nTime1 = GetTimeMicros();
 
     nLastBlockTx = nBlockTx;
     nLastBlockSize = nBlockSize;
 
     // Create coinbase transaction.
     CMutableTransaction coinbaseTx;
     coinbaseTx.vin.resize(1);
     coinbaseTx.vin[0].prevout = COutPoint();
     coinbaseTx.vout.resize(1);
     coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
     coinbaseTx.vout[0].nValue =
         nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
     // Make sure the coinbase is big enough.
     uint64_t coinbaseSize =
         ::GetSerializeSize(coinbaseTx, SER_NETWORK, PROTOCOL_VERSION);
     if (coinbaseSize < MIN_TX_SIZE) {
         coinbaseTx.vin[0].scriptSig
             << std::vector<uint8_t>(MIN_TX_SIZE - coinbaseSize - 1);
     }
 
     pblocktemplate->entries[0].tx = MakeTransactionRef(coinbaseTx);
     // Note: For the Coinbase, the template entry fields aside from the `tx` are
     // not used anywhere at the time of writing.  The mining rpc throws out the
     // entire transaction in fact. The tx itself is only used during regtest
     // mode.
     pblocktemplate->entries[0].txFee = -1 * nFees;
 
     uint64_t nSerializeSize =
         GetSerializeSize(*pblock, SER_NETWORK, PROTOCOL_VERSION);
 
     LogPrintf("CreateNewBlock(): total size: %u txs: %u fees: %ld sigops %d\n",
               nSerializeSize, nBlockTx, nFees, nBlockSigOps);
 
     // Fill in header.
     pblock->hashPrevBlock = pindexPrev->GetBlockHash();
     UpdateTime(pblock, *config, pindexPrev);
     pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, *config);
     pblock->nNonce = 0;
     pblocktemplate->entries[0].txSigOps = GetSigOpCountWithoutP2SH(
         *pblocktemplate->entries[0].tx, STANDARD_SCRIPT_VERIFY_FLAGS);
 
     // Copy all the transactions into the block
     // FIXME: This should be removed as it is significant overhead.
     // See T479
     for (const CBlockTemplateEntry &tx : pblocktemplate->entries) {
         pblock->vtx.push_back(tx.tx);
     }
 
     CValidationState state;
     BlockValidationOptions validationOptions(false, false);
     if (!TestBlockValidity(*config, state, *pblock, pindexPrev,
                            validationOptions)) {
         throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s",
                                            __func__,
                                            FormatStateMessage(state)));
     }
     int64_t nTime2 = GetTimeMicros();
 
     LogPrint(BCLog::BENCH,
              "CreateNewBlock() packages: %.2fms (%d packages, %d updated "
              "descendants), validity: %.2fms (total %.2fms)\n",
              0.001 * (nTime1 - nTimeStart), nPackagesSelected,
              nDescendantsUpdated, 0.001 * (nTime2 - nTime1),
              0.001 * (nTime2 - nTimeStart));
 
     return std::move(pblocktemplate);
 }
 
 bool BlockAssembler::isStillDependent(CTxMemPool::txiter iter) {
     for (CTxMemPool::txiter parent : mempool->GetMemPoolParents(iter)) {
         if (!inBlock.count(parent)) {
             return true;
         }
     }
     return false;
 }
 
 void BlockAssembler::onlyUnconfirmed(CTxMemPool::setEntries &testSet) {
     for (CTxMemPool::setEntries::iterator iit = testSet.begin();
          iit != testSet.end();) {
         // Only test txs not already in the block.
         if (inBlock.count(*iit)) {
             testSet.erase(iit++);
         } else {
             iit++;
         }
     }
 }
 
 bool BlockAssembler::TestPackage(uint64_t packageSize,
                                  int64_t packageSigOps) const {
     auto blockSizeWithPackage = nBlockSize + packageSize;
     if (blockSizeWithPackage >= nMaxGeneratedBlockSize) {
         return false;
     }
 
     if (nBlockSigOps + packageSigOps >=
         GetMaxBlockSigOpsCount(blockSizeWithPackage)) {
         return false;
     }
 
     return true;
 }
 
 /**
  * Perform transaction-level checks before adding to block:
  * - Transaction finality (locktime)
  * - Serialized size (in case -blockmaxsize is in use)
  */
 bool BlockAssembler::TestPackageTransactions(
     const CTxMemPool::setEntries &package) {
     uint64_t nPotentialBlockSize = nBlockSize;
     for (CTxMemPool::txiter it : package) {
         CValidationState state;
         if (!ContextualCheckTransaction(*config, it->GetTx(), state, nHeight,
                                         nLockTimeCutoff, nMedianTimePast)) {
             return false;
         }
 
         uint64_t nTxSize =
             ::GetSerializeSize(it->GetTx(), SER_NETWORK, PROTOCOL_VERSION);
         if (nPotentialBlockSize + nTxSize >= nMaxGeneratedBlockSize) {
             return false;
         }
 
         nPotentialBlockSize += nTxSize;
     }
 
     return true;
 }
 
 BlockAssembler::TestForBlockResult
 BlockAssembler::TestForBlock(CTxMemPool::txiter it) {
     auto blockSizeWithTx =
         nBlockSize +
         ::GetSerializeSize(it->GetTx(), SER_NETWORK, PROTOCOL_VERSION);
     if (blockSizeWithTx >= nMaxGeneratedBlockSize) {
         if (nBlockSize > nMaxGeneratedBlockSize - 100 || lastFewTxs > 50) {
             return TestForBlockResult::BlockFinished;
         }
 
         if (nBlockSize > nMaxGeneratedBlockSize - 1000) {
             lastFewTxs++;
         }
 
         return TestForBlockResult::TXCantFit;
     }
 
     auto maxBlockSigOps = GetMaxBlockSigOpsCount(blockSizeWithTx);
     if (nBlockSigOps + it->GetSigOpCount() >= maxBlockSigOps) {
         // If the block has room for no more sig ops then flag that the block is
         // finished.
         // TODO: We should consider adding another transaction that isn't very
         // dense in sigops instead of bailing out so easily.
         if (nBlockSigOps > maxBlockSigOps - 2) {
             return TestForBlockResult::BlockFinished;
         }
 
         // Otherwise attempt to find another tx with fewer sigops to put in the
         // block.
         return TestForBlockResult::TXCantFit;
     }
 
     // Must check that lock times are still valid. This can be removed once MTP
     // is always enforced as long as reorgs keep the mempool consistent.
     CValidationState state;
     if (!ContextualCheckTransaction(*config, it->GetTx(), state, nHeight,
                                     nLockTimeCutoff, nMedianTimePast)) {
         return TestForBlockResult::TXCantFit;
     }
 
     return TestForBlockResult::TXFits;
 }
 
 void BlockAssembler::AddToBlock(CTxMemPool::txiter iter) {
     pblocktemplate->entries.emplace_back(iter->GetSharedTx(), iter->GetFee(),
                                          iter->GetTxSize(),
                                          iter->GetSigOpCount());
     nBlockSize += iter->GetTxSize();
     ++nBlockTx;
     nBlockSigOps += iter->GetSigOpCount();
     nFees += iter->GetFee();
     inBlock.insert(iter);
 
     bool fPrintPriority =
         gArgs.GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY);
     if (fPrintPriority) {
         double dPriority = iter->GetPriority(nHeight);
         Amount dummy;
         mempool->ApplyDeltas(iter->GetTx().GetId(), dPriority, dummy);
         LogPrintf(
             "priority %.1f fee %s txid %s\n", dPriority,
             CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(),
             iter->GetTx().GetId().ToString());
     }
 }
 
 int BlockAssembler::UpdatePackagesForAdded(
     const CTxMemPool::setEntries &alreadyAdded,
     indexed_modified_transaction_set &mapModifiedTx) {
     int nDescendantsUpdated = 0;
     for (CTxMemPool::txiter it : alreadyAdded) {
         CTxMemPool::setEntries descendants;
         mempool->CalculateDescendants(it, descendants);
         // Insert all descendants (not yet in block) into the modified set.
         for (CTxMemPool::txiter desc : descendants) {
             if (alreadyAdded.count(desc)) {
                 continue;
             }
 
             ++nDescendantsUpdated;
             modtxiter mit = mapModifiedTx.find(desc);
             if (mit == mapModifiedTx.end()) {
                 CTxMemPoolModifiedEntry modEntry(desc);
                 modEntry.nSizeWithAncestors -= it->GetTxSize();
                 modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
                 modEntry.nSigOpCountWithAncestors -= it->GetSigOpCount();
                 mapModifiedTx.insert(modEntry);
             } else {
                 mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
             }
         }
     }
 
     return nDescendantsUpdated;
 }
 
 // Skip entries in mapTx that are already in a block or are present in
 // mapModifiedTx (which implies that the mapTx ancestor state is stale due to
 // ancestor inclusion in the block). Also skip transactions that we've already
 // failed to add. This can happen if we consider a transaction in mapModifiedTx
 // and it fails: we can then potentially consider it again while walking mapTx.
 // It's currently guaranteed to fail again, but as a belt-and-suspenders check
 // we put it in failedTx and avoid re-evaluation, since the re-evaluation would
 // be using cached size/sigops/fee values that are not actually correct.
 bool BlockAssembler::SkipMapTxEntry(
     CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx,
     CTxMemPool::setEntries &failedTx) {
     assert(it != mempool->mapTx.end());
     return mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it);
 }
 
 void BlockAssembler::SortForBlock(
     const CTxMemPool::setEntries &package,
     std::vector<CTxMemPool::txiter> &sortedEntries) {
     // Sort package by ancestor count. If a transaction A depends on transaction
     // B, then A's ancestor count must be greater than B's. So this is
     // sufficient to validly order the transactions for block inclusion.
     sortedEntries.clear();
     sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end());
     std::sort(sortedEntries.begin(), sortedEntries.end(),
               CompareTxIterByAncestorCount());
 }
 
 /**
  * addPackageTx includes transactions paying a fee by ensuring that
  * the partial ordering of transactions is maintained.  That is to say
  * children come after parents, despite having a potentially larger fee.
  * @param[out] nPackagesSelected    How many packages were selected
  * @param[out] nDescendantsUpdated  Number of descendant transactions updated
  */
 void BlockAssembler::addPackageTxs(int &nPackagesSelected,
                                    int &nDescendantsUpdated) {
 
     // selection algorithm orders the mempool based on feerate of a
     // transaction including all unconfirmed ancestors. Since we don't remove
     // transactions from the mempool as we select them for block inclusion, we
     // need an alternate method of updating the feerate of a transaction with
     // its not-yet-selected ancestors as we go. This is accomplished by
     // walking the in-mempool descendants of selected transactions and storing
     // a temporary modified state in mapModifiedTxs. Each time through the
     // loop, we compare the best transaction in mapModifiedTxs with the next
     // transaction in the mempool to decide what transaction package to work
     // on next.
 
     // mapModifiedTx will store sorted packages after they are modified because
     // some of their txs are already in the block.
     indexed_modified_transaction_set mapModifiedTx;
     // Keep track of entries that failed inclusion, to avoid duplicate work.
     CTxMemPool::setEntries failedTx;
 
     // Start by adding all descendants of previously added txs to mapModifiedTx
     // and modifying them for their already included ancestors.
     UpdatePackagesForAdded(inBlock, mapModifiedTx);
 
     CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator
         mi = mempool->mapTx.get<ancestor_score>().begin();
     CTxMemPool::txiter iter;
 
     // Limit the number of attempts to add transactions to the block when it is
     // close to full; this is just a simple heuristic to finish quickly if the
     // mempool has a lot of entries.
     const int64_t MAX_CONSECUTIVE_FAILURES = 1000;
     int64_t nConsecutiveFailed = 0;
 
     while (mi != mempool->mapTx.get<ancestor_score>().end() ||
            !mapModifiedTx.empty()) {
         // First try to find a new transaction in mapTx to evaluate.
         if (mi != mempool->mapTx.get<ancestor_score>().end() &&
             SkipMapTxEntry(mempool->mapTx.project<0>(mi), mapModifiedTx,
                            failedTx)) {
             ++mi;
             continue;
         }
 
         // Now that mi is not stale, determine which transaction to evaluate:
         // the next entry from mapTx, or the best from mapModifiedTx?
         bool fUsingModified = false;
 
         modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
         if (mi == mempool->mapTx.get<ancestor_score>().end()) {
             // We're out of entries in mapTx; use the entry from mapModifiedTx
             iter = modit->iter;
             fUsingModified = true;
         } else {
             // Try to compare the mapTx entry to the mapModifiedTx entry.
             iter = mempool->mapTx.project<0>(mi);
             if (modit != mapModifiedTx.get<ancestor_score>().end() &&
-                CompareModifiedEntry()(*modit, CTxMemPoolModifiedEntry(iter))) {
+                CompareTxMemPoolEntryByAncestorFee()(
+                    *modit, CTxMemPoolModifiedEntry(iter))) {
                 // The best entry in mapModifiedTx has higher score than the one
                 // from mapTx. Switch which transaction (package) to consider
                 iter = modit->iter;
                 fUsingModified = true;
             } else {
                 // Either no entry in mapModifiedTx, or it's worse than mapTx.
                 // Increment mi for the next loop iteration.
                 ++mi;
             }
         }
 
         // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
         // contain anything that is inBlock.
         assert(!inBlock.count(iter));
 
         uint64_t packageSize = iter->GetSizeWithAncestors();
         Amount packageFees = iter->GetModFeesWithAncestors();
         int64_t packageSigOps = iter->GetSigOpCountWithAncestors();
         if (fUsingModified) {
             packageSize = modit->nSizeWithAncestors;
             packageFees = modit->nModFeesWithAncestors;
             packageSigOps = modit->nSigOpCountWithAncestors;
         }
 
         if (packageFees < blockMinFeeRate.GetFee(packageSize)) {
             // Everything else we might consider has a lower fee rate
             return;
         }
 
         if (!TestPackage(packageSize, packageSigOps)) {
             if (fUsingModified) {
                 // Since we always look at the best entry in mapModifiedTx, we
                 // must erase failed entries so that we can consider the next
                 // best entry on the next loop iteration
                 mapModifiedTx.get<ancestor_score>().erase(modit);
                 failedTx.insert(iter);
             }
 
             ++nConsecutiveFailed;
 
             if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES &&
                 nBlockSize > nMaxGeneratedBlockSize - 1000) {
                 // Give up if we're close to full and haven't succeeded in a
                 // while.
                 break;
             }
 
             continue;
         }
 
         CTxMemPool::setEntries ancestors;
         uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
         std::string dummy;
         mempool->CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, nNoLimit,
                                            nNoLimit, nNoLimit, dummy, false);
 
         onlyUnconfirmed(ancestors);
         ancestors.insert(iter);
 
         // Test if all tx's are Final.
         if (!TestPackageTransactions(ancestors)) {
             if (fUsingModified) {
                 mapModifiedTx.get<ancestor_score>().erase(modit);
                 failedTx.insert(iter);
             }
             continue;
         }
 
         // This transaction will make it in; reset the failed counter.
         nConsecutiveFailed = 0;
 
         // Package can be added. Sort the entries in a valid order.
         std::vector<CTxMemPool::txiter> sortedEntries;
         SortForBlock(ancestors, sortedEntries);
 
         for (auto &entry : sortedEntries) {
             AddToBlock(entry);
             // Erase from the modified set, if present
             mapModifiedTx.erase(entry);
         }
 
         ++nPackagesSelected;
 
         // Update transactions that depend on each of these
         nDescendantsUpdated += UpdatePackagesForAdded(ancestors, mapModifiedTx);
     }
 }
 
 void BlockAssembler::addPriorityTxs() {
     // How much of the block should be dedicated to high-priority transactions,
     // included regardless of the fees they pay.
     if (config->GetBlockPriorityPercentage() == 0) {
         return;
     }
 
     uint64_t nBlockPrioritySize =
         nMaxGeneratedBlockSize * config->GetBlockPriorityPercentage() / 100;
 
     // This vector will be sorted into a priority queue:
     std::vector<TxCoinAgePriority> vecPriority;
     TxCoinAgePriorityCompare pricomparer;
     std::map<CTxMemPool::txiter, double, CTxMemPool::CompareIteratorByHash>
         waitPriMap;
     typedef std::map<CTxMemPool::txiter, double,
                      CTxMemPool::CompareIteratorByHash>::iterator waitPriIter;
     double actualPriority = -1;
 
     vecPriority.reserve(mempool->mapTx.size());
     for (CTxMemPool::indexed_transaction_set::iterator mi =
              mempool->mapTx.begin();
          mi != mempool->mapTx.end(); ++mi) {
         double dPriority = mi->GetPriority(nHeight);
         Amount dummy;
         mempool->ApplyDeltas(mi->GetTx().GetId(), dPriority, dummy);
         vecPriority.push_back(TxCoinAgePriority(dPriority, mi));
     }
     std::make_heap(vecPriority.begin(), vecPriority.end(), pricomparer);
 
     CTxMemPool::txiter iter;
 
     // Add a tx from priority queue to fill the part of block reserved to
     // priority transactions.
     while (!vecPriority.empty()) {
         iter = vecPriority.front().second;
         actualPriority = vecPriority.front().first;
         std::pop_heap(vecPriority.begin(), vecPriority.end(), pricomparer);
         vecPriority.pop_back();
 
         // If tx already in block, skip.
         if (inBlock.count(iter)) {
             // Shouldn't happen for priority txs.
             assert(false);
             continue;
         }
 
         // If tx is dependent on other mempool txs which haven't yet been
         // included then put it in the waitSet.
         if (isStillDependent(iter)) {
             waitPriMap.insert(std::make_pair(iter, actualPriority));
             continue;
         }
 
         TestForBlockResult testResult = TestForBlock(iter);
         // Break if the block is completed
         if (testResult == TestForBlockResult::BlockFinished) {
             break;
         }
 
         // If this tx does not fit in the block, skip to next transaction.
         if (testResult != TestForBlockResult::TXFits) {
             continue;
         }
 
         AddToBlock(iter);
 
         // If now that this txs is added we've surpassed our desired priority
         // size, then we're done adding priority transactions.
         if (nBlockSize >= nBlockPrioritySize) {
             break;
         }
 
         // if we have dropped below the AllowFreeThreshold, then we're done
         // adding priority transactions.
         if (!AllowFree(actualPriority)) {
             break;
         }
 
         // This tx was successfully added, so add transactions that depend
         // on this one to the priority queue to try again.
         for (CTxMemPool::txiter child : mempool->GetMemPoolChildren(iter)) {
             waitPriIter wpiter = waitPriMap.find(child);
             if (wpiter == waitPriMap.end()) {
                 continue;
             }
 
             vecPriority.push_back(TxCoinAgePriority(wpiter->second, child));
             std::push_heap(vecPriority.begin(), vecPriority.end(), pricomparer);
             waitPriMap.erase(wpiter);
         }
     }
 }
 
 void IncrementExtraNonce(const Config &config, CBlock *pblock,
                          const CBlockIndex *pindexPrev,
                          unsigned int &nExtraNonce) {
     // Update nExtraNonce
     static uint256 hashPrevBlock;
     if (hashPrevBlock != pblock->hashPrevBlock) {
         nExtraNonce = 0;
         hashPrevBlock = pblock->hashPrevBlock;
     }
 
     ++nExtraNonce;
     // Height first in coinbase required for block.version=2
     unsigned int nHeight = pindexPrev->nHeight + 1;
     CMutableTransaction txCoinbase(*pblock->vtx[0]);
     txCoinbase.vin[0].scriptSig =
         (CScript() << nHeight << CScriptNum(nExtraNonce)
                    << getExcessiveBlockSizeSig(config)) +
         COINBASE_FLAGS;
 
     // Make sure the coinbase is big enough.
     uint64_t coinbaseSize =
         ::GetSerializeSize(txCoinbase, SER_NETWORK, PROTOCOL_VERSION);
     if (coinbaseSize < MIN_TX_SIZE) {
         txCoinbase.vin[0].scriptSig
             << std::vector<uint8_t>(MIN_TX_SIZE - coinbaseSize - 1);
     }
 
     assert(txCoinbase.vin[0].scriptSig.size() <= MAX_COINBASE_SCRIPTSIG_SIZE);
     assert(::GetSerializeSize(txCoinbase, SER_NETWORK, PROTOCOL_VERSION) >=
            MIN_TX_SIZE);
 
     pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
     pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
 }
diff --git a/src/miner.h b/src/miner.h
index 06f1f5355..c65494d5e 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -1,249 +1,240 @@
 // 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_MINER_H
 #define BITCOIN_MINER_H
 
 #include <primitives/block.h>
 #include <txmempool.h>
 
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index_container.hpp>
 
 #include <cstdint>
 #include <memory>
 
 class CBlockIndex;
 class CChainParams;
 class Config;
 class CScript;
 
 static const bool DEFAULT_PRINTPRIORITY = false;
 
 struct CBlockTemplateEntry {
     CTransactionRef tx;
     //!< Total real fees paid by the transaction and cached to avoid parent
     //!< lookup
     Amount txFee;
     //!< Cached total size of the transaction to avoid reserializing transaction
     size_t txSize;
     //!< Cached total number of SigOps
     uint64_t txSigOps;
 
     CBlockTemplateEntry(CTransactionRef _tx, Amount _fees, uint64_t _size,
                         int64_t _sigOps)
         : tx(_tx), txFee(_fees), txSize(_size), txSigOps(_sigOps) {}
 };
 
 struct CBlockTemplate {
     CBlock block;
 
     std::vector<CBlockTemplateEntry> entries;
 };
 
 // Container for tracking updates to ancestor feerate as we include (parent)
 // transactions in a block
 struct CTxMemPoolModifiedEntry {
     explicit CTxMemPoolModifiedEntry(CTxMemPool::txiter entry) {
         iter = entry;
         nSizeWithAncestors = entry->GetSizeWithAncestors();
         nModFeesWithAncestors = entry->GetModFeesWithAncestors();
         nSigOpCountWithAncestors = entry->GetSigOpCountWithAncestors();
     }
 
+    Amount GetModifiedFee() const { return iter->GetModifiedFee(); }
+    uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
+    Amount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
+    size_t GetTxSize() const { return iter->GetTxSize(); }
+    const CTransaction &GetTx() const { return iter->GetTx(); }
+
     CTxMemPool::txiter iter;
     uint64_t nSizeWithAncestors;
     Amount nModFeesWithAncestors;
     int64_t nSigOpCountWithAncestors;
 };
 
 /**
  * Comparator for CTxMemPool::txiter objects.
  * It simply compares the internal memory address of the CTxMemPoolEntry object
  * pointed to. This means it has no meaning, and is only useful for using them
  * as key in other indexes.
  */
 struct CompareCTxMemPoolIter {
     bool operator()(const CTxMemPool::txiter &a,
                     const CTxMemPool::txiter &b) const {
         return &(*a) < &(*b);
     }
 };
 
 struct modifiedentry_iter {
     typedef CTxMemPool::txiter result_type;
     result_type operator()(const CTxMemPoolModifiedEntry &entry) const {
         return entry.iter;
     }
 };
 
-// This matches the calculation in CompareTxMemPoolEntryByAncestorFee,
-// except operating on CTxMemPoolModifiedEntry.
-// TODO: refactor to avoid duplication of this logic.
-struct CompareModifiedEntry {
-    bool operator()(const CTxMemPoolModifiedEntry &a,
-                    const CTxMemPoolModifiedEntry &b) const {
-        double f1 = b.nSizeWithAncestors * (a.nModFeesWithAncestors / SATOSHI);
-        double f2 = a.nSizeWithAncestors * (b.nModFeesWithAncestors / SATOSHI);
-        if (f1 == f2) {
-            return CTxMemPool::CompareIteratorByHash()(a.iter, b.iter);
-        }
-        return f1 > f2;
-    }
-};
-
 // A comparator that sorts transactions based on number of ancestors.
 // This is sufficient to sort an ancestor package in an order that is valid
 // to appear in a block.
 struct CompareTxIterByAncestorCount {
     bool operator()(const CTxMemPool::txiter &a,
                     const CTxMemPool::txiter &b) const {
         if (a->GetCountWithAncestors() != b->GetCountWithAncestors()) {
             return a->GetCountWithAncestors() < b->GetCountWithAncestors();
         }
         return CTxMemPool::CompareIteratorByHash()(a, b);
     }
 };
 
 typedef boost::multi_index_container<
     CTxMemPoolModifiedEntry,
     boost::multi_index::indexed_by<
         boost::multi_index::ordered_unique<modifiedentry_iter,
                                            CompareCTxMemPoolIter>,
         // sorted by modified ancestor fee rate
         boost::multi_index::ordered_non_unique<
             // Reuse same tag from CTxMemPool's similar index
             boost::multi_index::tag<ancestor_score>,
             boost::multi_index::identity<CTxMemPoolModifiedEntry>,
-            CompareModifiedEntry>>>
+            CompareTxMemPoolEntryByAncestorFee>>>
     indexed_modified_transaction_set;
 
 typedef indexed_modified_transaction_set::nth_index<0>::type::iterator
     modtxiter;
 typedef indexed_modified_transaction_set::index<ancestor_score>::type::iterator
     modtxscoreiter;
 
 struct update_for_parent_inclusion {
     explicit update_for_parent_inclusion(CTxMemPool::txiter it) : iter(it) {}
 
     void operator()(CTxMemPoolModifiedEntry &e) {
         e.nModFeesWithAncestors -= iter->GetFee();
         e.nSizeWithAncestors -= iter->GetTxSize();
         e.nSigOpCountWithAncestors -= iter->GetSigOpCount();
     }
 
     CTxMemPool::txiter iter;
 };
 
 /** Generate a new block, without valid proof-of-work */
 class BlockAssembler {
 private:
     // The constructed block template
     std::unique_ptr<CBlockTemplate> pblocktemplate;
     // A convenience pointer that always refers to the CBlock in pblocktemplate
     CBlock *pblock;
 
     // Configuration parameters for the block size
     uint64_t nMaxGeneratedBlockSize;
     CFeeRate blockMinFeeRate;
 
     // Information on the current status of the block
     uint64_t nBlockSize;
     uint64_t nBlockTx;
     uint64_t nBlockSigOps;
     Amount nFees;
     CTxMemPool::setEntries inBlock;
 
     // Chain context for the block
     int nHeight;
     int64_t nLockTimeCutoff;
     int64_t nMedianTimePast;
 
     const Config *config;
     const CTxMemPool *mempool;
 
     // Variables used for addPriorityTxs
     int lastFewTxs;
 
 public:
     BlockAssembler(const Config &_config, const CTxMemPool &mempool);
     /** Construct a new block template with coinbase to scriptPubKeyIn */
     std::unique_ptr<CBlockTemplate>
     CreateNewBlock(const CScript &scriptPubKeyIn);
 
     uint64_t GetMaxGeneratedBlockSize() const { return nMaxGeneratedBlockSize; }
 
 private:
     // utility functions
     /** Clear the block's state and prepare for assembling a new block */
     void resetBlock();
     /** Add a tx to the block */
     void AddToBlock(CTxMemPool::txiter iter);
 
     // Methods for how to add transactions to a block.
     /** Add transactions based on tx "priority" */
     void addPriorityTxs() EXCLUSIVE_LOCKS_REQUIRED(mempool->cs);
     /**
      * Add transactions based on feerate including unconfirmed ancestors.
      * Increments nPackagesSelected / nDescendantsUpdated with corresponding
      * statistics from the package selection (for logging statistics).
      */
     void addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated)
         EXCLUSIVE_LOCKS_REQUIRED(mempool->cs);
 
     /** Enum for the results from TestForBlock */
     enum class TestForBlockResult : uint8_t {
         TXFits = 0,
         TXCantFit = 1,
         BlockFinished = 3,
     };
 
     // helper function for addPriorityTxs
     /** Test if tx will still "fit" in the block */
     TestForBlockResult TestForBlock(CTxMemPool::txiter iter);
     /** Test if tx still has unconfirmed parents not yet in block */
     bool isStillDependent(CTxMemPool::txiter iter)
         EXCLUSIVE_LOCKS_REQUIRED(mempool->cs);
 
     // helper functions for addPackageTxs()
     /** Remove confirmed (inBlock) entries from given set */
     void onlyUnconfirmed(CTxMemPool::setEntries &testSet);
     /** Test if a new package would "fit" in the block */
     bool TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const;
     /**
      * Perform checks on each transaction in a package:
      * locktime, serialized size (if necessary). These checks should always
      * succeed, and they're here only as an extra check in case of suboptimal
      * node configuration.
      */
     bool TestPackageTransactions(const CTxMemPool::setEntries &package);
     /**
      * Return true if given transaction from mapTx has already been evaluated,
      * or if the transaction's cached data in mapTx is incorrect.
      */
     bool SkipMapTxEntry(CTxMemPool::txiter it,
                         indexed_modified_transaction_set &mapModifiedTx,
                         CTxMemPool::setEntries &failedTx)
         EXCLUSIVE_LOCKS_REQUIRED(mempool->cs);
     /** Sort the package in an order that is valid to appear in a block */
     void SortForBlock(const CTxMemPool::setEntries &package,
                       std::vector<CTxMemPool::txiter> &sortedEntries);
     /**
      * Add descendants of given transactions to mapModifiedTx with ancestor
      * state updated assuming given transactions are inBlock. Returns number of
      * updated descendants.
      */
     int UpdatePackagesForAdded(const CTxMemPool::setEntries &alreadyAdded,
                                indexed_modified_transaction_set &mapModifiedTx)
         EXCLUSIVE_LOCKS_REQUIRED(mempool->cs);
 };
 
 /** Modify the extranonce in a block */
 void IncrementExtraNonce(const Config &config, CBlock *pblock,
                          const CBlockIndex *pindexPrev,
                          unsigned int &nExtraNonce);
 int64_t UpdateTime(CBlockHeader *pblock, const Config &config,
                    const CBlockIndex *pindexPrev);
 #endif // BITCOIN_MINER_H
diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index 69ec9e7ca..d7677bd8d 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -1,1035 +1,1054 @@
 // Copyright (c) 2011-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 <txmempool.h>
 
 #include <policy/policy.h>
 #include <reverse_iterator.h>
 #include <util.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>
 #include <list>
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(mempool_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(TestPackageAccounting) {
     CTxMemPool testPool;
     LOCK(testPool.cs);
     TestMemPoolEntryHelper entry;
     CMutableTransaction parentOfAll;
 
     std::vector<CTxIn> outpoints;
     const size_t maxOutputs = 3;
 
     // Construct a parent for the rest of the chain
     parentOfAll.vin.resize(1);
     parentOfAll.vin[0].scriptSig = CScript();
     // Give us a couple outpoints so we can spend them
     for (size_t i = 0; i < maxOutputs; i++) {
         parentOfAll.vout.emplace_back(10 * SATOSHI, CScript() << OP_TRUE);
     }
     TxId parentOfAllId = parentOfAll.GetId();
     testPool.addUnchecked(parentOfAllId, entry.FromTx(parentOfAll));
 
     // Add some outpoints to the tracking vector
     for (size_t i = 0; i < maxOutputs; i++) {
         outpoints.emplace_back(COutPoint(parentOfAllId, i));
     }
 
     Amount totalFee = Amount::zero();
     size_t totalSize = CTransaction(parentOfAll).GetTotalSize();
 
     // Generate 100 transactions
     for (size_t totalTransactions = 0; totalTransactions < 100;
          totalTransactions++) {
         CMutableTransaction tx;
 
         uint64_t minAncestors = std::numeric_limits<size_t>::max();
         uint64_t maxAncestors = 0;
         Amount minFees = MAX_MONEY;
         Amount maxFees = Amount::zero();
         uint64_t minSize = std::numeric_limits<size_t>::max();
         uint64_t maxSize = 0;
         // Consume random inputs, but make sure we don't consume more than
         // available
         for (size_t input = std::min(InsecureRandRange(maxOutputs) + 1,
                                      uint64_t(outpoints.size()));
              input > 0; input--) {
             std::swap(outpoints[InsecureRandRange(outpoints.size())],
                       outpoints.back());
             tx.vin.emplace_back(outpoints.back());
             outpoints.pop_back();
 
             // We don't know exactly how many ancestors this transaction has
             // due to possible duplicates.  Calculate a valid range based on
             // parents.
 
             CTxMemPoolEntry parent =
                 *testPool.mapTx.find(tx.vin.back().prevout.GetTxId());
 
             minAncestors =
                 std::min(minAncestors, parent.GetCountWithAncestors());
             maxAncestors += parent.GetCountWithAncestors();
             minFees = std::min(minFees, parent.GetModFeesWithAncestors());
             maxFees += parent.GetModFeesWithAncestors();
             minSize = std::min(minSize, parent.GetSizeWithAncestors());
             maxSize += parent.GetSizeWithAncestors();
         }
 
         // Produce random number of outputs
         for (size_t output = InsecureRandRange(maxOutputs) + 1; output > 0;
              output--) {
             tx.vout.emplace_back(10 * SATOSHI, CScript() << OP_TRUE);
         }
 
         TxId curId = tx.GetId();
 
         // Record the outputs
         for (size_t output = tx.vout.size(); output > 0; output--) {
             outpoints.emplace_back(COutPoint(curId, output));
         }
 
         Amount randFee = int64_t(InsecureRandRange(300)) * SATOSHI;
 
         testPool.addUnchecked(curId, entry.Fee(randFee).FromTx(tx));
 
         // Add this transaction to the totals.
         minAncestors += 1;
         maxAncestors += 1;
         minFees += randFee;
         maxFees += randFee;
         minSize += CTransaction(tx).GetTotalSize();
         maxSize += CTransaction(tx).GetTotalSize();
 
         // Calculate overall values
         totalFee += randFee;
         totalSize += CTransaction(tx).GetTotalSize();
         CTxMemPoolEntry parentEntry = *testPool.mapTx.find(parentOfAllId);
         CTxMemPoolEntry latestEntry = *testPool.mapTx.find(curId);
 
         // Ensure values are within the expected ranges
         BOOST_CHECK(latestEntry.GetCountWithAncestors() >= minAncestors);
         BOOST_CHECK(latestEntry.GetCountWithAncestors() <= maxAncestors);
 
         BOOST_CHECK(latestEntry.GetSizeWithAncestors() >= minSize);
         BOOST_CHECK(latestEntry.GetSizeWithAncestors() <= maxSize);
 
         BOOST_CHECK(latestEntry.GetModFeesWithAncestors() >= minFees);
         BOOST_CHECK(latestEntry.GetModFeesWithAncestors() <= maxFees);
 
         BOOST_CHECK_EQUAL(parentEntry.GetCountWithDescendants(),
                           testPool.mapTx.size());
         BOOST_CHECK_EQUAL(parentEntry.GetSizeWithDescendants(), totalSize);
         BOOST_CHECK_EQUAL(parentEntry.GetModFeesWithDescendants(), totalFee);
     }
 }
 
 BOOST_AUTO_TEST_CASE(MempoolRemoveTest) {
     // Test CTxMemPool::remove functionality
 
     TestMemPoolEntryHelper entry;
     // Parent transaction with three children, and three grand-children:
     CMutableTransaction txParent;
     txParent.vin.resize(1);
     txParent.vin[0].scriptSig = CScript() << OP_11;
     txParent.vout.resize(3);
     for (int i = 0; i < 3; i++) {
         txParent.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txParent.vout[i].nValue = 33000 * SATOSHI;
     }
     CMutableTransaction txChild[3];
     for (int i = 0; i < 3; i++) {
         txChild[i].vin.resize(1);
         txChild[i].vin[0].scriptSig = CScript() << OP_11;
         txChild[i].vin[0].prevout = COutPoint(txParent.GetId(), i);
         txChild[i].vout.resize(1);
         txChild[i].vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txChild[i].vout[0].nValue = 11000 * SATOSHI;
     }
     CMutableTransaction txGrandChild[3];
     for (int i = 0; i < 3; i++) {
         txGrandChild[i].vin.resize(1);
         txGrandChild[i].vin[0].scriptSig = CScript() << OP_11;
         txGrandChild[i].vin[0].prevout = COutPoint(txChild[i].GetId(), 0);
         txGrandChild[i].vout.resize(1);
         txGrandChild[i].vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txGrandChild[i].vout[0].nValue = 11000 * SATOSHI;
     }
 
     CTxMemPool testPool;
 
     // Nothing in pool, remove should do nothing:
     unsigned int poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize);
 
     // Just the parent:
     testPool.addUnchecked(txParent.GetId(), entry.FromTx(txParent));
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 1);
 
     // Parent, children, grandchildren:
     testPool.addUnchecked(txParent.GetId(), entry.FromTx(txParent));
     for (int i = 0; i < 3; i++) {
         testPool.addUnchecked(txChild[i].GetId(), entry.FromTx(txChild[i]));
         testPool.addUnchecked(txGrandChild[i].GetId(),
                               entry.FromTx(txGrandChild[i]));
     }
     // Remove Child[0], GrandChild[0] should be removed:
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txChild[0]));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 2);
     // ... make sure grandchild and child are gone:
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txGrandChild[0]));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize);
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txChild[0]));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize);
     // Remove parent, all children/grandchildren should go:
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 5);
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
 
     // Add children and grandchildren, but NOT the parent (simulate the parent
     // being in a block)
     for (int i = 0; i < 3; i++) {
         testPool.addUnchecked(txChild[i].GetId(), entry.FromTx(txChild[i]));
         testPool.addUnchecked(txGrandChild[i].GetId(),
                               entry.FromTx(txGrandChild[i]));
     }
 
     // Now remove the parent, as might happen if a block-re-org occurs but the
     // parent cannot be put into the mempool (maybe because it is non-standard):
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent));
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 6);
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
 }
 
 BOOST_AUTO_TEST_CASE(MempoolClearTest) {
     // Test CTxMemPool::clear functionality
 
     TestMemPoolEntryHelper entry;
     // Create a transaction
     CMutableTransaction txParent;
     txParent.vin.resize(1);
     txParent.vin[0].scriptSig = CScript() << OP_11;
     txParent.vout.resize(3);
     for (int i = 0; i < 3; i++) {
         txParent.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txParent.vout[i].nValue = 33000 * SATOSHI;
     }
 
     CTxMemPool testPool;
     LOCK(testPool.cs);
 
     // Nothing in pool, clear should do nothing:
     testPool.clear();
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
 
     // Add the transaction
     testPool.addUnchecked(txParent.GetId(), entry.FromTx(txParent));
     BOOST_CHECK_EQUAL(testPool.size(), 1UL);
     BOOST_CHECK_EQUAL(testPool.mapTx.size(), 1UL);
     BOOST_CHECK_EQUAL(testPool.mapNextTx.size(), 1UL);
     BOOST_CHECK_EQUAL(testPool.vTxHashes.size(), 1UL);
 
     // CTxMemPool's members should be empty after a clear
     testPool.clear();
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
     BOOST_CHECK_EQUAL(testPool.mapTx.size(), 0UL);
     BOOST_CHECK_EQUAL(testPool.mapNextTx.size(), 0UL);
     BOOST_CHECK_EQUAL(testPool.vTxHashes.size(), 0UL);
 }
 
 template <typename name>
 static void CheckSort(CTxMemPool &pool, std::vector<std::string> &sortedOrder,
                       const std::string &testcase)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs) {
     BOOST_CHECK_EQUAL(pool.size(), sortedOrder.size());
     typename CTxMemPool::indexed_transaction_set::index<name>::type::iterator
         it = pool.mapTx.get<name>().begin();
     int count = 0;
     for (; it != pool.mapTx.get<name>().end(); ++it, ++count) {
         BOOST_CHECK_MESSAGE(it->GetTx().GetId().ToString() ==
                                 sortedOrder[count],
                             it->GetTx().GetId().ToString()
                                 << " != " << sortedOrder[count] << " in test "
                                 << testcase << ":" << count);
     }
 }
 
 BOOST_AUTO_TEST_CASE(MempoolIndexingTest) {
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
 
     /* 3rd highest fee */
     CMutableTransaction tx1 = CMutableTransaction();
     tx1.vout.resize(1);
     tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx1.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(tx1.GetId(),
                       entry.Fee(10000 * SATOSHI).Priority(10.0).FromTx(tx1));
 
     /* highest fee */
     CMutableTransaction tx2 = CMutableTransaction();
     tx2.vout.resize(1);
     tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx2.vout[0].nValue = 2 * COIN;
     pool.addUnchecked(tx2.GetId(),
                       entry.Fee(20000 * SATOSHI).Priority(9.0).FromTx(tx2));
 
     /* lowest fee */
     CMutableTransaction tx3 = CMutableTransaction();
     tx3.vout.resize(1);
     tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx3.vout[0].nValue = 5 * COIN;
     pool.addUnchecked(tx3.GetId(),
                       entry.Fee(Amount::zero()).Priority(100.0).FromTx(tx3));
 
     /* 2nd highest fee */
     CMutableTransaction tx4 = CMutableTransaction();
     tx4.vout.resize(1);
     tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx4.vout[0].nValue = 6 * COIN;
     pool.addUnchecked(tx4.GetId(),
                       entry.Fee(15000 * SATOSHI).Priority(1.0).FromTx(tx4));
 
     /* equal fee rate to tx1, but newer */
     CMutableTransaction tx5 = CMutableTransaction();
     tx5.vout.resize(1);
     tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx5.vout[0].nValue = 11 * COIN;
     entry.nTime = 1;
     entry.dPriority = 10.0;
     pool.addUnchecked(tx5.GetId(), entry.Fee(10000 * SATOSHI).FromTx(tx5));
     BOOST_CHECK_EQUAL(pool.size(), 5UL);
 
     std::vector<std::string> sortedOrder;
     sortedOrder.resize(5);
     sortedOrder[0] = tx3.GetId().ToString(); // 0
     sortedOrder[1] = tx5.GetId().ToString(); // 10000
     sortedOrder[2] = tx1.GetId().ToString(); // 10000
     sortedOrder[3] = tx4.GetId().ToString(); // 15000
     sortedOrder[4] = tx2.GetId().ToString(); // 20000
     LOCK(pool.cs);
     CheckSort<descendant_score>(pool, sortedOrder, "MempoolIndexingTest1");
 
     /* low fee but with high fee child */
     /* tx6 -> tx7 -> tx8, tx9 -> tx10 */
     CMutableTransaction tx6 = CMutableTransaction();
     tx6.vout.resize(1);
     tx6.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx6.vout[0].nValue = 20 * COIN;
     pool.addUnchecked(tx6.GetId(), entry.Fee(Amount::zero()).FromTx(tx6));
     BOOST_CHECK_EQUAL(pool.size(), 6UL);
     // Check that at this point, tx6 is sorted low
     sortedOrder.insert(sortedOrder.begin(), tx6.GetId().ToString());
     CheckSort<descendant_score>(pool, sortedOrder, "MempoolIndexingTest2");
 
     CTxMemPool::setEntries setAncestors;
     setAncestors.insert(pool.mapTx.find(tx6.GetId()));
     CMutableTransaction tx7 = CMutableTransaction();
     tx7.vin.resize(1);
     tx7.vin[0].prevout = COutPoint(tx6.GetId(), 0);
     tx7.vin[0].scriptSig = CScript() << OP_11;
     tx7.vout.resize(2);
     tx7.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx7.vout[0].nValue = 10 * COIN;
     tx7.vout[1].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx7.vout[1].nValue = 1 * COIN;
 
     CTxMemPool::setEntries setAncestorsCalculated;
     std::string dummy;
     BOOST_CHECK_EQUAL(
         pool.CalculateMemPoolAncestors(entry.Fee(2000000 * SATOSHI).FromTx(tx7),
                                        setAncestorsCalculated, 100, 1000000,
                                        1000, 1000000, dummy),
         true);
     BOOST_CHECK(setAncestorsCalculated == setAncestors);
 
     pool.addUnchecked(tx7.GetId(), entry.FromTx(tx7), setAncestors);
     BOOST_CHECK_EQUAL(pool.size(), 7UL);
 
     // Now tx6 should be sorted higher (high fee child): tx7, tx6, tx2, ...
     sortedOrder.erase(sortedOrder.begin());
     sortedOrder.push_back(tx6.GetId().ToString());
     sortedOrder.push_back(tx7.GetId().ToString());
     CheckSort<descendant_score>(pool, sortedOrder, "MempoolIndexingTest3");
 
     /* low fee child of tx7 */
     CMutableTransaction tx8 = CMutableTransaction();
     tx8.vin.resize(1);
     tx8.vin[0].prevout = COutPoint(tx7.GetId(), 0);
     tx8.vin[0].scriptSig = CScript() << OP_11;
     tx8.vout.resize(1);
     tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx8.vout[0].nValue = 10 * COIN;
     setAncestors.insert(pool.mapTx.find(tx7.GetId()));
     pool.addUnchecked(tx8.GetId(),
                       entry.Fee(Amount::zero()).Time(2).FromTx(tx8),
                       setAncestors);
 
     // Now tx8 should be sorted low, but tx6/tx both high
     sortedOrder.insert(sortedOrder.begin(), tx8.GetId().ToString());
     CheckSort<descendant_score>(pool, sortedOrder, "MempoolIndexingTest4");
 
     /* low fee child of tx7 */
     CMutableTransaction tx9 = CMutableTransaction();
     tx9.vin.resize(1);
     tx9.vin[0].prevout = COutPoint(tx7.GetId(), 1);
     tx9.vin[0].scriptSig = CScript() << OP_11;
     tx9.vout.resize(1);
     tx9.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx9.vout[0].nValue = 1 * COIN;
     pool.addUnchecked(tx9.GetId(),
                       entry.Fee(Amount::zero()).Time(3).FromTx(tx9),
                       setAncestors);
 
     // tx9 should be sorted low
     BOOST_CHECK_EQUAL(pool.size(), 9UL);
     sortedOrder.insert(sortedOrder.begin(), tx9.GetId().ToString());
     CheckSort<descendant_score>(pool, sortedOrder, "MempoolIndexingTest5");
 
     std::vector<std::string> snapshotOrder = sortedOrder;
 
     setAncestors.insert(pool.mapTx.find(tx8.GetId()));
     setAncestors.insert(pool.mapTx.find(tx9.GetId()));
     /* tx10 depends on tx8 and tx9 and has a high fee*/
     CMutableTransaction tx10 = CMutableTransaction();
     tx10.vin.resize(2);
     tx10.vin[0].prevout = COutPoint(tx8.GetId(), 0);
     tx10.vin[0].scriptSig = CScript() << OP_11;
     tx10.vin[1].prevout = COutPoint(tx9.GetId(), 0);
     tx10.vin[1].scriptSig = CScript() << OP_11;
     tx10.vout.resize(1);
     tx10.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx10.vout[0].nValue = 10 * COIN;
 
     setAncestorsCalculated.clear();
     BOOST_CHECK_EQUAL(pool.CalculateMemPoolAncestors(
                           entry.Fee(200000 * SATOSHI).Time(4).FromTx(tx10),
                           setAncestorsCalculated, 100, 1000000, 1000, 1000000,
                           dummy),
                       true);
     BOOST_CHECK(setAncestorsCalculated == setAncestors);
 
     pool.addUnchecked(tx10.GetId(), entry.FromTx(tx10), setAncestors);
 
     /**
      *  tx8 and tx9 should both now be sorted higher
      *  Final order after tx10 is added:
      *
      *  tx3 = 0 (1)
      *  tx5 = 10000 (1)
      *  tx1 = 10000 (1)
      *  tx4 = 15000 (1)
      *  tx2 = 20000 (1)
      *  tx9 = 200k (2 txs)
      *  tx8 = 200k (2 txs)
      *  tx10 = 200k (1 tx)
      *  tx6 = 2.2M (5 txs)
      *  tx7 = 2.2M (4 txs)
      */
     // take out tx9, tx8 from the beginning
     sortedOrder.erase(sortedOrder.begin(), sortedOrder.begin() + 2);
     sortedOrder.insert(sortedOrder.begin() + 5, tx9.GetId().ToString());
     sortedOrder.insert(sortedOrder.begin() + 6, tx8.GetId().ToString());
     // tx10 is just before tx6
     sortedOrder.insert(sortedOrder.begin() + 7, tx10.GetId().ToString());
     CheckSort<descendant_score>(pool, sortedOrder, "MempoolIndexingTest6");
 
     // there should be 10 transactions in the mempool
     BOOST_CHECK_EQUAL(pool.size(), 10UL);
 
     // Now try removing tx10 and verify the sort order returns to normal
     pool.removeRecursive(pool.mapTx.find(tx10.GetId())->GetTx());
     CheckSort<descendant_score>(pool, snapshotOrder, "MempoolIndexingTest7");
 
     pool.removeRecursive(pool.mapTx.find(tx9.GetId())->GetTx());
     pool.removeRecursive(pool.mapTx.find(tx8.GetId())->GetTx());
 }
 
 BOOST_AUTO_TEST_CASE(MempoolAncestorIndexingTest) {
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
 
     /* 3rd highest fee */
     CMutableTransaction tx1 = CMutableTransaction();
     tx1.vout.resize(1);
     tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx1.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(tx1.GetId(),
                       entry.Fee(10000 * SATOSHI).Priority(10.0).FromTx(tx1));
 
     /* highest fee */
     CMutableTransaction tx2 = CMutableTransaction();
     tx2.vout.resize(1);
     tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx2.vout[0].nValue = 2 * COIN;
     pool.addUnchecked(tx2.GetId(),
                       entry.Fee(20000 * SATOSHI).Priority(9.0).FromTx(tx2));
     uint64_t tx2Size = CTransaction(tx2).GetTotalSize();
 
     /* lowest fee */
     CMutableTransaction tx3 = CMutableTransaction();
     tx3.vout.resize(1);
     tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx3.vout[0].nValue = 5 * COIN;
     pool.addUnchecked(tx3.GetId(),
                       entry.Fee(Amount::zero()).Priority(100.0).FromTx(tx3));
 
     /* 2nd highest fee */
     CMutableTransaction tx4 = CMutableTransaction();
     tx4.vout.resize(1);
     tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx4.vout[0].nValue = 6 * COIN;
     pool.addUnchecked(tx4.GetId(),
                       entry.Fee(15000 * SATOSHI).Priority(1.0).FromTx(tx4));
 
     /* equal fee rate to tx1, but newer */
     CMutableTransaction tx5 = CMutableTransaction();
     tx5.vout.resize(1);
     tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx5.vout[0].nValue = 11 * COIN;
     pool.addUnchecked(tx5.GetId(), entry.Fee(10000 * SATOSHI).FromTx(tx5));
     BOOST_CHECK_EQUAL(pool.size(), 5UL);
 
     std::vector<std::string> sortedOrder;
     sortedOrder.resize(5);
     sortedOrder[0] = tx2.GetId().ToString(); // 20000
     sortedOrder[1] = tx4.GetId().ToString(); // 15000
     // tx1 and tx5 are both 10000
     // Ties are broken by hash, not timestamp, so determine which hash comes
     // first.
     if (tx1.GetId() < tx5.GetId()) {
         sortedOrder[2] = tx1.GetId().ToString();
         sortedOrder[3] = tx5.GetId().ToString();
     } else {
         sortedOrder[2] = tx5.GetId().ToString();
         sortedOrder[3] = tx1.GetId().ToString();
     }
     sortedOrder[4] = tx3.GetId().ToString(); // 0
 
     LOCK(pool.cs);
     CheckSort<ancestor_score>(pool, sortedOrder,
                               "MempoolAncestorIndexingTest1");
 
     /* low fee parent with high fee child */
     /* tx6 (0) -> tx7 (high) */
     CMutableTransaction tx6 = CMutableTransaction();
     tx6.vout.resize(1);
     tx6.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx6.vout[0].nValue = 20 * COIN;
     uint64_t tx6Size = CTransaction(tx6).GetTotalSize();
 
     pool.addUnchecked(tx6.GetId(), entry.Fee(Amount::zero()).FromTx(tx6));
     BOOST_CHECK_EQUAL(pool.size(), 6UL);
     // Ties are broken by hash
     if (tx3.GetId() < tx6.GetId()) {
         sortedOrder.push_back(tx6.GetId().ToString());
     } else {
         sortedOrder.insert(sortedOrder.end() - 1, tx6.GetId().ToString());
     }
 
     CheckSort<ancestor_score>(pool, sortedOrder,
                               "MempoolAncestorIndexingTest2");
 
     CMutableTransaction tx7 = CMutableTransaction();
     tx7.vin.resize(1);
     tx7.vin[0].prevout = COutPoint(tx6.GetId(), 0);
     tx7.vin[0].scriptSig = CScript() << OP_11;
     tx7.vout.resize(1);
     tx7.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx7.vout[0].nValue = 10 * COIN;
     uint64_t tx7Size = CTransaction(tx7).GetTotalSize();
 
     /* set the fee to just below tx2's feerate when including ancestor */
     Amount fee = int64_t((20000 / tx2Size) * (tx7Size + tx6Size) - 1) * SATOSHI;
 
     // CTxMemPoolEntry entry7(tx7, fee, 2, 10.0, 1, true);
     pool.addUnchecked(tx7.GetId(), entry.Fee(Amount(fee)).FromTx(tx7));
     BOOST_CHECK_EQUAL(pool.size(), 7UL);
     sortedOrder.insert(sortedOrder.begin() + 1, tx7.GetId().ToString());
     CheckSort<ancestor_score>(pool, sortedOrder,
                               "MempoolAncestorIndexingTest3");
 
     /* after tx6 is mined, tx7 should move up in the sort */
     std::vector<CTransactionRef> vtx;
     vtx.push_back(MakeTransactionRef(tx6));
     pool.removeForBlock(vtx, 1);
 
     sortedOrder.erase(sortedOrder.begin() + 1);
     // Ties are broken by hash
     if (tx3.GetId() < tx6.GetId()) {
         sortedOrder.pop_back();
     } else {
         sortedOrder.erase(sortedOrder.end() - 2);
     }
     sortedOrder.insert(sortedOrder.begin(), tx7.GetId().ToString());
     CheckSort<ancestor_score>(pool, sortedOrder,
                               "MempoolAncestorIndexingTest4");
+
+    // High-fee parent, low-fee child
+    // tx7 -> tx8
+    CMutableTransaction tx8 = CMutableTransaction();
+    tx8.vin.resize(1);
+    tx8.vin[0].prevout = COutPoint(tx7.GetId(), 0);
+    tx8.vin[0].scriptSig = CScript() << OP_11;
+    tx8.vout.resize(1);
+    tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx8.vout[0].nValue = 10 * COIN;
+
+    // Check that we sort by min(feerate, ancestor_feerate):
+    // set the fee so that the ancestor feerate is above tx1/5,
+    // but the transaction's own feerate is lower
+    pool.addUnchecked(tx8.GetId(),
+                      entry.Fee(Amount(5000 * SATOSHI)).FromTx(tx8));
+    sortedOrder.insert(sortedOrder.end() - 1, tx8.GetId().ToString());
+    CheckSort<ancestor_score>(pool, sortedOrder,
+                              "MempoolAncestorIndexingTest5");
 }
 
 BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest) {
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
     entry.dPriority = 10.0;
     Amount feeIncrement = MEMPOOL_FULL_FEE_INCREMENT.GetFeePerK();
 
     CMutableTransaction tx1 = CMutableTransaction();
     tx1.vin.resize(1);
     tx1.vin[0].scriptSig = CScript() << OP_1;
     tx1.vout.resize(1);
     tx1.vout[0].scriptPubKey = CScript() << OP_1 << OP_EQUAL;
     tx1.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(tx1.GetId(),
                       entry.Fee(10000 * SATOSHI).FromTx(tx1, &pool));
 
     CMutableTransaction tx2 = CMutableTransaction();
     tx2.vin.resize(1);
     tx2.vin[0].scriptSig = CScript() << OP_2;
     tx2.vout.resize(1);
     tx2.vout[0].scriptPubKey = CScript() << OP_2 << OP_EQUAL;
     tx2.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(tx2.GetId(),
                       entry.Fee(5000 * SATOSHI).FromTx(tx2, &pool));
 
     // should do nothing
     pool.TrimToSize(pool.DynamicMemoryUsage());
     BOOST_CHECK(pool.exists(tx1.GetId()));
     BOOST_CHECK(pool.exists(tx2.GetId()));
 
     // should remove the lower-feerate transaction
     pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
     BOOST_CHECK(pool.exists(tx1.GetId()));
     BOOST_CHECK(!pool.exists(tx2.GetId()));
 
     pool.addUnchecked(tx2.GetId(), entry.FromTx(tx2, &pool));
     CMutableTransaction tx3 = CMutableTransaction();
     tx3.vin.resize(1);
     tx3.vin[0].prevout = COutPoint(tx2.GetId(), 0);
     tx3.vin[0].scriptSig = CScript() << OP_2;
     tx3.vout.resize(1);
     tx3.vout[0].scriptPubKey = CScript() << OP_3 << OP_EQUAL;
     tx3.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(tx3.GetId(),
                       entry.Fee(20000 * SATOSHI).FromTx(tx3, &pool));
 
     // tx3 should pay for tx2 (CPFP)
     pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
     BOOST_CHECK(!pool.exists(tx1.GetId()));
     BOOST_CHECK(pool.exists(tx2.GetId()));
     BOOST_CHECK(pool.exists(tx3.GetId()));
 
     // mempool is limited to tx1's size in memory usage, so nothing fits
     pool.TrimToSize(CTransaction(tx1).GetTotalSize());
     BOOST_CHECK(!pool.exists(tx1.GetId()));
     BOOST_CHECK(!pool.exists(tx2.GetId()));
     BOOST_CHECK(!pool.exists(tx3.GetId()));
 
     CFeeRate maxFeeRateRemoved(25000 * SATOSHI,
                                CTransaction(tx3).GetTotalSize() +
                                    CTransaction(tx2).GetTotalSize());
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(),
                       maxFeeRateRemoved.GetFeePerK() + feeIncrement);
 
     CMutableTransaction tx4 = CMutableTransaction();
     tx4.vin.resize(2);
     tx4.vin[0].prevout = COutPoint();
     tx4.vin[0].scriptSig = CScript() << OP_4;
     tx4.vin[1].prevout = COutPoint();
     tx4.vin[1].scriptSig = CScript() << OP_4;
     tx4.vout.resize(2);
     tx4.vout[0].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
     tx4.vout[0].nValue = 10 * COIN;
     tx4.vout[1].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
     tx4.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx5 = CMutableTransaction();
     tx5.vin.resize(2);
     tx5.vin[0].prevout = COutPoint(tx4.GetId(), 0);
     tx5.vin[0].scriptSig = CScript() << OP_4;
     tx5.vin[1].prevout = COutPoint();
     tx5.vin[1].scriptSig = CScript() << OP_5;
     tx5.vout.resize(2);
     tx5.vout[0].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
     tx5.vout[0].nValue = 10 * COIN;
     tx5.vout[1].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
     tx5.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx6 = CMutableTransaction();
     tx6.vin.resize(2);
     tx6.vin[0].prevout = COutPoint(tx4.GetId(), 1);
     tx6.vin[0].scriptSig = CScript() << OP_4;
     tx6.vin[1].prevout = COutPoint();
     tx6.vin[1].scriptSig = CScript() << OP_6;
     tx6.vout.resize(2);
     tx6.vout[0].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
     tx6.vout[0].nValue = 10 * COIN;
     tx6.vout[1].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
     tx6.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx7 = CMutableTransaction();
     tx7.vin.resize(2);
     tx7.vin[0].prevout = COutPoint(tx5.GetId(), 0);
     tx7.vin[0].scriptSig = CScript() << OP_5;
     tx7.vin[1].prevout = COutPoint(tx6.GetId(), 0);
     tx7.vin[1].scriptSig = CScript() << OP_6;
     tx7.vout.resize(2);
     tx7.vout[0].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
     tx7.vout[0].nValue = 10 * COIN;
     tx7.vout[1].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
     tx7.vout[1].nValue = 10 * COIN;
 
     pool.addUnchecked(tx4.GetId(),
                       entry.Fee(7000 * SATOSHI).FromTx(tx4, &pool));
     pool.addUnchecked(tx5.GetId(),
                       entry.Fee(1000 * SATOSHI).FromTx(tx5, &pool));
     pool.addUnchecked(tx6.GetId(),
                       entry.Fee(1100 * SATOSHI).FromTx(tx6, &pool));
     pool.addUnchecked(tx7.GetId(),
                       entry.Fee(9000 * SATOSHI).FromTx(tx7, &pool));
 
     // we only require this remove, at max, 2 txn, because its not clear what
     // we're really optimizing for aside from that
     pool.TrimToSize(pool.DynamicMemoryUsage() - 1);
     BOOST_CHECK(pool.exists(tx4.GetId()));
     BOOST_CHECK(pool.exists(tx6.GetId()));
     BOOST_CHECK(!pool.exists(tx7.GetId()));
 
     if (!pool.exists(tx5.GetId()))
         pool.addUnchecked(tx5.GetId(),
                           entry.Fee(1000 * SATOSHI).FromTx(tx5, &pool));
     pool.addUnchecked(tx7.GetId(),
                       entry.Fee(9000 * SATOSHI).FromTx(tx7, &pool));
 
     // should maximize mempool size by only removing 5/7
     pool.TrimToSize(pool.DynamicMemoryUsage() / 2);
     BOOST_CHECK(pool.exists(tx4.GetId()));
     BOOST_CHECK(!pool.exists(tx5.GetId()));
     BOOST_CHECK(pool.exists(tx6.GetId()));
     BOOST_CHECK(!pool.exists(tx7.GetId()));
 
     pool.addUnchecked(tx5.GetId(),
                       entry.Fee(1000 * SATOSHI).FromTx(tx5, &pool));
     pool.addUnchecked(tx7.GetId(),
                       entry.Fee(9000 * SATOSHI).FromTx(tx7, &pool));
 
     std::vector<CTransactionRef> vtx;
     SetMockTime(42);
     SetMockTime(42 + CTxMemPool::ROLLING_FEE_HALFLIFE);
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(),
                       maxFeeRateRemoved.GetFeePerK() + feeIncrement);
     // ... we should keep the same min fee until we get a block
     pool.removeForBlock(vtx, 1);
     SetMockTime(42 + 2 * CTxMemPool::ROLLING_FEE_HALFLIFE);
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(),
                       (maxFeeRateRemoved.GetFeePerK() + feeIncrement) / 2);
     // ... then feerate should drop 1/2 each halflife
 
     SetMockTime(42 + 2 * CTxMemPool::ROLLING_FEE_HALFLIFE +
                 CTxMemPool::ROLLING_FEE_HALFLIFE / 2);
     BOOST_CHECK_EQUAL(
         pool.GetMinFee(pool.DynamicMemoryUsage() * 5 / 2).GetFeePerK(),
         (maxFeeRateRemoved.GetFeePerK() + feeIncrement) / 4);
     // ... with a 1/2 halflife when mempool is < 1/2 its target size
 
     SetMockTime(42 + 2 * CTxMemPool::ROLLING_FEE_HALFLIFE +
                 CTxMemPool::ROLLING_FEE_HALFLIFE / 2 +
                 CTxMemPool::ROLLING_FEE_HALFLIFE / 4);
     BOOST_CHECK_EQUAL(
         pool.GetMinFee(pool.DynamicMemoryUsage() * 9 / 2).GetFeePerK(),
         (maxFeeRateRemoved.GetFeePerK() + feeIncrement) / 8 + SATOSHI);
     // ... with a 1/4 halflife when mempool is < 1/4 its target size
 
     SetMockTime(0);
 }
 
 // expectedSize can be smaller than correctlyOrderedIds.size(), since we
 // might be testing intermediary states. Just avoiding some slice operations,
 void CheckDisconnectPoolOrder(DisconnectedBlockTransactions &disconnectPool,
                               std::vector<TxId> correctlyOrderedIds,
                               unsigned int expectedSize) {
     int i = 0;
     BOOST_CHECK_EQUAL(disconnectPool.GetQueuedTx().size(), expectedSize);
     // Txns in queuedTx's insertion_order index are sorted from children to
     // parent txn
     for (const CTransactionRef &tx :
          reverse_iterate(disconnectPool.GetQueuedTx().get<insertion_order>())) {
         BOOST_CHECK(tx->GetId() == correctlyOrderedIds[i]);
         i++;
     }
 }
 
 typedef std::vector<CMutableTransaction *> vecptx;
 
 BOOST_AUTO_TEST_CASE(TestImportMempool) {
     CMutableTransaction chainedTxn[5];
     std::vector<TxId> correctlyOrderedIds;
     COutPoint lastOutpoint;
 
     // Construct a chain of 5 transactions
     for (int i = 0; i < 5; i++) {
         chainedTxn[i].vin.emplace_back(lastOutpoint);
         chainedTxn[i].vout.emplace_back(10 * SATOSHI, CScript() << OP_TRUE);
         correctlyOrderedIds.push_back(chainedTxn[i].GetId());
         lastOutpoint = COutPoint(correctlyOrderedIds[i], 0);
     }
 
     // The first 3 txns simulate once confirmed transactions that have been
     // disconnected. We test 3 different orders: in order, one case of mixed
     // order and inverted order.
     vecptx disconnectedTxnsInOrder = {&chainedTxn[0], &chainedTxn[1],
                                       &chainedTxn[2]};
     vecptx disconnectedTxnsMixedOrder = {&chainedTxn[1], &chainedTxn[2],
                                          &chainedTxn[0]};
     vecptx disconnectedTxnsInvertedOrder = {&chainedTxn[2], &chainedTxn[1],
                                             &chainedTxn[0]};
 
     // The last 2 txns simulate a chain of unconfirmed transactions in the
     // mempool. We test 2 different orders: in and out of order.
     vecptx unconfTxnsInOrder = {&chainedTxn[3], &chainedTxn[4]};
     vecptx unconfTxnsOutOfOrder = {&chainedTxn[4], &chainedTxn[3]};
 
     // Now we test all combinations of the previously defined orders for
     // disconnected and unconfirmed txns. The expected outcome is to have these
     // transactions in the correct order in queuedTx, as defined in
     // correctlyOrderedIds.
     for (auto &disconnectedTxns :
          {disconnectedTxnsInOrder, disconnectedTxnsMixedOrder,
           disconnectedTxnsInvertedOrder}) {
         for (auto &unconfTxns : {unconfTxnsInOrder, unconfTxnsOutOfOrder}) {
             // addForBlock inserts disconnectTxns in disconnectPool. They
             // simulate transactions that were once confirmed in a block
             std::vector<CTransactionRef> vtx;
             for (auto tx : disconnectedTxns) {
                 vtx.push_back(MakeTransactionRef(*tx));
             }
             DisconnectedBlockTransactions disconnectPool;
             disconnectPool.addForBlock(vtx);
             CheckDisconnectPoolOrder(disconnectPool, correctlyOrderedIds,
                                      disconnectedTxns.size());
 
             // If the mempool is empty, importMempool doesn't change
             // disconnectPool
             CTxMemPool testPool;
             disconnectPool.importMempool(testPool);
             CheckDisconnectPoolOrder(disconnectPool, correctlyOrderedIds,
                                      disconnectedTxns.size());
 
             // Add all unconfirmed transactions in testPool
             for (auto tx : unconfTxns) {
                 TestMemPoolEntryHelper entry;
                 testPool.addUnchecked(tx->GetId(), entry.FromTx(*tx));
             }
 
             // Now we test importMempool with a non empty mempool
             disconnectPool.importMempool(testPool);
             CheckDisconnectPoolOrder(disconnectPool, correctlyOrderedIds,
                                      disconnectedTxns.size() +
                                          unconfTxns.size());
             // We must clear disconnectPool to not trigger the assert in its
             // destructor
             disconnectPool.clear();
         }
     }
 }
 
 inline CTransactionRef
 make_tx(std::vector<Amount> &&output_values,
         std::vector<CTransactionRef> &&inputs = std::vector<CTransactionRef>(),
         std::vector<uint32_t> &&input_indices = std::vector<uint32_t>()) {
     CMutableTransaction tx = CMutableTransaction();
     tx.vin.resize(inputs.size());
     tx.vout.resize(output_values.size());
     for (size_t i = 0; i < inputs.size(); ++i) {
         tx.vin[i].prevout =
             COutPoint(inputs[i]->GetId(),
                       input_indices.size() > i ? input_indices[i] : 0);
     }
     for (size_t i = 0; i < output_values.size(); ++i) {
         tx.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         tx.vout[i].nValue = output_values[i];
     }
     return MakeTransactionRef(tx);
 }
 
 #define MK_OUTPUTS(amounts...)                                                 \
     std::vector<Amount> { amounts }
 #define MK_INPUTS(txs...)                                                      \
     std::vector<CTransactionRef> { txs }
 #define MK_INPUT_IDX(idxes...)                                                 \
     std::vector<uint32_t> { idxes }
 
 BOOST_AUTO_TEST_CASE(MempoolAncestryTests) {
     size_t ancestors, descendants;
 
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
 
     /* Base transaction */
     //
     // [tx1]
     //
     CTransactionRef tx1 = make_tx(MK_OUTPUTS(10 * COIN));
     pool.addUnchecked(tx1->GetId(), entry.Fee(10000 * SATOSHI).FromTx(tx1));
 
     // Ancestors / descendants should be 1 / 1 (itself / itself)
     pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
     BOOST_CHECK_EQUAL(descendants, 1ULL);
 
     /* Child transaction */
     //
     // [tx1].0 <- [tx2]
     //
     CTransactionRef tx2 =
         make_tx(MK_OUTPUTS(495 * CENT, 5 * COIN), MK_INPUTS(tx1));
     pool.addUnchecked(tx2->GetId(), entry.Fee(10000 * SATOSHI).FromTx(tx2));
 
     // Ancestors / descendants should be:
     // transaction  ancestors   descendants
     // ============ =========== ===========
     // tx1          1 (tx1)     2 (tx1,2)
     // tx2          2 (tx1,2)   2 (tx1,2)
     pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
     BOOST_CHECK_EQUAL(descendants, 2ULL);
     pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
     BOOST_CHECK_EQUAL(descendants, 2ULL);
 
     /* Grand-child 1 */
     //
     // [tx1].0 <- [tx2].0 <- [tx3]
     //
     CTransactionRef tx3 =
         make_tx(MK_OUTPUTS(290 * CENT, 200 * CENT), MK_INPUTS(tx2));
     pool.addUnchecked(tx3->GetId(), entry.Fee(10000 * SATOSHI).FromTx(tx3));
 
     // Ancestors / descendants should be:
     // transaction  ancestors   descendants
     // ============ =========== ===========
     // tx1          1 (tx1)     3 (tx1,2,3)
     // tx2          2 (tx1,2)   3 (tx1,2,3)
     // tx3          3 (tx1,2,3) 3 (tx1,2,3)
     pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
     BOOST_CHECK_EQUAL(descendants, 3ULL);
     pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
     BOOST_CHECK_EQUAL(descendants, 3ULL);
     pool.GetTransactionAncestry(tx3->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
     BOOST_CHECK_EQUAL(descendants, 3ULL);
 
     /* Grand-child 2 */
     //
     // [tx1].0 <- [tx2].0 <- [tx3]
     //              |
     //              \---1 <- [tx4]
     //
     CTransactionRef tx4 = make_tx(MK_OUTPUTS(290 * CENT, 250 * CENT),
                                   MK_INPUTS(tx2), MK_INPUT_IDX(1));
     pool.addUnchecked(tx4->GetId(), entry.Fee(10000 * SATOSHI).FromTx(tx4));
 
     // Ancestors / descendants should be:
     // transaction  ancestors   descendants
     // ============ =========== ===========
     // tx1          1 (tx1)     4 (tx1,2,3,4)
     // tx2          2 (tx1,2)   4 (tx1,2,3,4)
     // tx3          3 (tx1,2,3) 4 (tx1,2,3,4)
     // tx4          3 (tx1,2,4) 4 (tx1,2,3,4)
     pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
     BOOST_CHECK_EQUAL(descendants, 4ULL);
     pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
     BOOST_CHECK_EQUAL(descendants, 4ULL);
     pool.GetTransactionAncestry(tx3->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
     BOOST_CHECK_EQUAL(descendants, 4ULL);
     pool.GetTransactionAncestry(tx4->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
     BOOST_CHECK_EQUAL(descendants, 4ULL);
 
     /* Make an alternate branch that is longer and connect it to tx3 */
     //
     // [ty1].0 <- [ty2].0 <- [ty3].0 <- [ty4].0 <- [ty5].0
     //                                              |
     // [tx1].0 <- [tx2].0 <- [tx3].0 <- [ty6] --->--/
     //              |
     //              \---1 <- [tx4]
     //
     CTransactionRef ty1, ty2, ty3, ty4, ty5;
     CTransactionRef *ty[5] = {&ty1, &ty2, &ty3, &ty4, &ty5};
     Amount v = 5 * COIN;
     for (uint64_t i = 0; i < 5; i++) {
         CTransactionRef &tyi = *ty[i];
         tyi = make_tx(MK_OUTPUTS(v), i > 0 ? MK_INPUTS(*ty[i - 1])
                                            : std::vector<CTransactionRef>());
         v -= 50 * CENT;
         pool.addUnchecked(tyi->GetId(), entry.Fee(10000 * SATOSHI).FromTx(tyi));
         pool.GetTransactionAncestry(tyi->GetId(), ancestors, descendants);
         BOOST_CHECK_EQUAL(ancestors, i + 1);
         BOOST_CHECK_EQUAL(descendants, i + 1);
     }
     CTransactionRef ty6 = make_tx(MK_OUTPUTS(5 * COIN), MK_INPUTS(tx3, ty5));
     pool.addUnchecked(ty6->GetId(), entry.Fee(10000 * SATOSHI).FromTx(ty6));
 
     // Ancestors / descendants should be:
     // transaction  ancestors           descendants
     // ============ =================== ===========
     // tx1          1 (tx1)             5 (tx1,2,3,4, ty6)
     // tx2          2 (tx1,2)           5 (tx1,2,3,4, ty6)
     // tx3          3 (tx1,2,3)         5 (tx1,2,3,4, ty6)
     // tx4          3 (tx1,2,4)         5 (tx1,2,3,4, ty6)
     // ty1          1 (ty1)             6 (ty1,2,3,4,5,6)
     // ty2          2 (ty1,2)           6 (ty1,2,3,4,5,6)
     // ty3          3 (ty1,2,3)         6 (ty1,2,3,4,5,6)
     // ty4          4 (y1234)           6 (ty1,2,3,4,5,6)
     // ty5          5 (y12345)          6 (ty1,2,3,4,5,6)
     // ty6          9 (tx123, ty123456) 6 (ty1,2,3,4,5,6)
     pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
     BOOST_CHECK_EQUAL(descendants, 5ULL);
     pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
     BOOST_CHECK_EQUAL(descendants, 5ULL);
     pool.GetTransactionAncestry(tx3->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
     BOOST_CHECK_EQUAL(descendants, 5ULL);
     pool.GetTransactionAncestry(tx4->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
     BOOST_CHECK_EQUAL(descendants, 5ULL);
     pool.GetTransactionAncestry(ty1->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
     BOOST_CHECK_EQUAL(descendants, 6ULL);
     pool.GetTransactionAncestry(ty2->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
     BOOST_CHECK_EQUAL(descendants, 6ULL);
     pool.GetTransactionAncestry(ty3->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
     BOOST_CHECK_EQUAL(descendants, 6ULL);
     pool.GetTransactionAncestry(ty4->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 4ULL);
     BOOST_CHECK_EQUAL(descendants, 6ULL);
     pool.GetTransactionAncestry(ty5->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 5ULL);
     BOOST_CHECK_EQUAL(descendants, 6ULL);
     pool.GetTransactionAncestry(ty6->GetId(), ancestors, descendants);
     BOOST_CHECK_EQUAL(ancestors, 9ULL);
     BOOST_CHECK_EQUAL(descendants, 6ULL);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txmempool.h b/src/txmempool.h
index 5a82002a3..1e6c9a2ab 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -1,918 +1,938 @@
 // 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_TXMEMPOOL_H
 #define BITCOIN_TXMEMPOOL_H
 
 #include <amount.h>
 #include <coins.h>
 #include <crypto/siphash.h>
 #include <indirectmap.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <sync.h>
 
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/sequenced_index.hpp>
 #include <boost/multi_index_container.hpp>
 #include <boost/signals2/signal.hpp>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 class CBlockIndex;
 class Config;
 
 inline double AllowFreeThreshold() {
     return (144 * COIN) / (250 * SATOSHI);
 }
 
 inline bool AllowFree(double dPriority) {
     // Large (in bytes) low-priority (new, small-coin) transactions need a fee.
     return dPriority > AllowFreeThreshold();
 }
 
 /**
  * Fake height value used in Coins to signify they are only in the memory
  * pool(since 0.8)
  */
 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
 
 struct LockPoints {
     // Will be set to the blockchain height and median time past values that
     // would be necessary to satisfy all relative locktime constraints (BIP68)
     // of this tx given our view of block chain history
     int height;
     int64_t time;
     // As long as the current chain descends from the highest height block
     // containing one of the inputs used in the calculation, then the cached
     // values are still valid even after a reorg.
     CBlockIndex *maxInputBlock;
 
     LockPoints() : height(0), time(0), maxInputBlock(nullptr) {}
 };
 
 class CTxMemPool;
 
 /** \class CTxMemPoolEntry
  *
  * CTxMemPoolEntry stores data about the corresponding transaction, as well as
  * data about all in-mempool transactions that depend on the transaction
  * ("descendant" transactions).
  *
  * When a new entry is added to the mempool, we update the descendant state
  * (nCountWithDescendants, nSizeWithDescendants, and nModFeesWithDescendants)
  * for all ancestors of the newly added transaction.
  */
 
 class CTxMemPoolEntry {
 private:
     CTransactionRef tx;
     //!< Cached to avoid expensive parent-transaction lookups
     Amount nFee;
     //!< ... and avoid recomputing tx size
     size_t nTxSize;
     //!< ... and modified size for priority
     size_t nModSize;
     //!< ... and total memory usage
     size_t nUsageSize;
     //!< Local time when entering the mempool
     int64_t nTime;
     //!< Priority when entering the mempool
     double entryPriority;
     //!< Chain height when entering the mempool
     unsigned int entryHeight;
     //!< Sum of all txin values that are already in blockchain
     Amount inChainInputValue;
     //!< keep track of transactions that spend a coinbase
     bool spendsCoinbase;
     //!< Total sigop plus P2SH sigops count
     int64_t sigOpCount;
     //!< Used for determining the priority of the transaction for mining in a
     //! block
     Amount feeDelta;
     //!< Track the height and time at which tx was final
     LockPoints lockPoints;
 
     // Information about descendants of this transaction that are in the
     // mempool; if we remove this transaction we must remove all of these
     // descendants as well.
     //!< number of descendant transactions
     uint64_t nCountWithDescendants;
     //!< ... and size
     uint64_t nSizeWithDescendants;
 
     //!< ... and total fees (all including us)
     Amount nModFeesWithDescendants;
 
     // Analogous statistics for ancestor transactions
     uint64_t nCountWithAncestors;
     uint64_t nSizeWithAncestors;
     Amount nModFeesWithAncestors;
     int64_t nSigOpCountWithAncestors;
 
 public:
     CTxMemPoolEntry(const CTransactionRef &_tx, const Amount _nFee,
                     int64_t _nTime, double _entryPriority,
                     unsigned int _entryHeight, Amount _inChainInputValue,
                     bool spendsCoinbase, int64_t nSigOpsCost, LockPoints lp);
 
     const CTransaction &GetTx() const { return *this->tx; }
     CTransactionRef GetSharedTx() const { return this->tx; }
     /**
      * Fast calculation of lower bound of current priority as update from entry
      * priority. Only inputs that were originally in-chain will age.
      */
     double GetPriority(unsigned int currentHeight) const;
     const Amount GetFee() const { return nFee; }
     size_t GetTxSize() const { return nTxSize; }
 
     int64_t GetTime() const { return nTime; }
     unsigned int GetHeight() const { return entryHeight; }
     int64_t GetSigOpCount() const { return sigOpCount; }
     Amount GetModifiedFee() const { return nFee + feeDelta; }
     size_t DynamicMemoryUsage() const { return nUsageSize; }
     const LockPoints &GetLockPoints() const { return lockPoints; }
 
     // Adjusts the descendant state.
     void UpdateDescendantState(int64_t modifySize, Amount modifyFee,
                                int64_t modifyCount);
     // Adjusts the ancestor state
     void UpdateAncestorState(int64_t modifySize, Amount modifyFee,
                              int64_t modifyCount, int modifySigOps);
     // Updates the fee delta used for mining priority score, and the
     // modified fees with descendants.
     void UpdateFeeDelta(Amount feeDelta);
     // Update the LockPoints after a reorg
     void UpdateLockPoints(const LockPoints &lp);
 
     uint64_t GetCountWithDescendants() const { return nCountWithDescendants; }
     uint64_t GetSizeWithDescendants() const { return nSizeWithDescendants; }
     Amount GetModFeesWithDescendants() const { return nModFeesWithDescendants; }
 
     bool GetSpendsCoinbase() const { return spendsCoinbase; }
 
     uint64_t GetCountWithAncestors() const { return nCountWithAncestors; }
     uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
     Amount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
     int64_t GetSigOpCountWithAncestors() const {
         return nSigOpCountWithAncestors;
     }
 
     //!< Index in mempool's vTxHashes
     mutable size_t vTxHashesIdx;
 };
 
 // Helpers for modifying CTxMemPool::mapTx, which is a boost multi_index.
 struct update_descendant_state {
     update_descendant_state(int64_t _modifySize, Amount _modifyFee,
                             int64_t _modifyCount)
         : modifySize(_modifySize), modifyFee(_modifyFee),
           modifyCount(_modifyCount) {}
 
     void operator()(CTxMemPoolEntry &e) {
         e.UpdateDescendantState(modifySize, modifyFee, modifyCount);
     }
 
 private:
     int64_t modifySize;
     Amount modifyFee;
     int64_t modifyCount;
 };
 
 struct update_ancestor_state {
     update_ancestor_state(int64_t _modifySize, Amount _modifyFee,
                           int64_t _modifyCount, int64_t _modifySigOpsCost)
         : modifySize(_modifySize), modifyFee(_modifyFee),
           modifyCount(_modifyCount), modifySigOpsCost(_modifySigOpsCost) {}
 
     void operator()(CTxMemPoolEntry &e) {
         e.UpdateAncestorState(modifySize, modifyFee, modifyCount,
                               modifySigOpsCost);
     }
 
 private:
     int64_t modifySize;
     Amount modifyFee;
     int64_t modifyCount;
     int64_t modifySigOpsCost;
 };
 
 struct update_fee_delta {
     explicit update_fee_delta(Amount _feeDelta) : feeDelta(_feeDelta) {}
 
     void operator()(CTxMemPoolEntry &e) { e.UpdateFeeDelta(feeDelta); }
 
 private:
     Amount feeDelta;
 };
 
 struct update_lock_points {
     explicit update_lock_points(const LockPoints &_lp) : lp(_lp) {}
 
     void operator()(CTxMemPoolEntry &e) { e.UpdateLockPoints(lp); }
 
 private:
     const LockPoints &lp;
 };
 
 // extracts a transaction hash from CTxMempoolEntry or CTransactionRef
 struct mempoolentry_txid {
     typedef uint256 result_type;
     result_type operator()(const CTxMemPoolEntry &entry) const {
         return entry.GetTx().GetId();
     }
 
     result_type operator()(const CTransactionRef &tx) const {
         return tx->GetId();
     }
 };
 
 /** \class CompareTxMemPoolEntryByDescendantScore
  *
  *  Sort an entry by max(score/size of entry's tx, score/size with all
  * descendants).
  */
 class CompareTxMemPoolEntryByDescendantScore {
 public:
     bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
-        bool fUseADescendants = UseDescendantScore(a);
-        bool fUseBDescendants = UseDescendantScore(b);
+        double a_mod_fee, a_size, b_mod_fee, b_size;
 
-        double aModFee = (fUseADescendants ? a.GetModFeesWithDescendants()
-                                           : a.GetModifiedFee()) /
-                         SATOSHI;
-        double aSize =
-            fUseADescendants ? a.GetSizeWithDescendants() : a.GetTxSize();
-
-        double bModFee = (fUseBDescendants ? b.GetModFeesWithDescendants()
-                                           : b.GetModifiedFee()) /
-                         SATOSHI;
-        double bSize =
-            fUseBDescendants ? b.GetSizeWithDescendants() : b.GetTxSize();
+        GetModFeeAndSize(a, a_mod_fee, a_size);
+        GetModFeeAndSize(b, b_mod_fee, b_size);
 
         // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
-        double f1 = aModFee * bSize;
-        double f2 = aSize * bModFee;
+        double f1 = a_mod_fee * b_size;
+        double f2 = a_size * b_mod_fee;
 
         if (f1 == f2) {
             return a.GetTime() >= b.GetTime();
         }
         return f1 < f2;
     }
 
-    // Calculate which score to use for an entry (avoiding division).
-    bool UseDescendantScore(const CTxMemPoolEntry &a) const {
+    // Return the fee/size we're using for sorting this entry.
+    void GetModFeeAndSize(const CTxMemPoolEntry &a, double &mod_fee,
+                          double &size) const {
+        // Compare feerate with descendants to feerate of the transaction, and
+        // return the fee/size for the max.
         double f1 = a.GetSizeWithDescendants() * (a.GetModifiedFee() / SATOSHI);
         double f2 = a.GetTxSize() * (a.GetModFeesWithDescendants() / SATOSHI);
-        return f2 > f1;
+
+        if (f2 > f1) {
+            mod_fee = a.GetModFeesWithDescendants() / SATOSHI;
+            size = a.GetSizeWithDescendants();
+        } else {
+            mod_fee = a.GetModifiedFee() / SATOSHI;
+            size = a.GetTxSize();
+        }
     }
 };
 
 /** \class CompareTxMemPoolEntryByScore
  *
  *  Sort by score of entry ((fee+delta)/size) in descending order
  */
 class CompareTxMemPoolEntryByScore {
 public:
     bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
         double f1 = b.GetTxSize() * (a.GetModifiedFee() / SATOSHI);
         double f2 = a.GetTxSize() * (b.GetModifiedFee() / SATOSHI);
         if (f1 == f2) {
             return b.GetTx().GetId() < a.GetTx().GetId();
         }
         return f1 > f2;
     }
 };
 
 class CompareTxMemPoolEntryByEntryTime {
 public:
     bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
         return a.GetTime() < b.GetTime();
     }
 };
 
+/** \class CompareTxMemPoolEntryByAncestorScore
+ *
+ *  Sort an entry by min(score/size of entry's tx, score/size with all
+ * ancestors).
+ */
 class CompareTxMemPoolEntryByAncestorFee {
 public:
-    bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
-        double aFees = a.GetModFeesWithAncestors() / SATOSHI;
-        double aSize = a.GetSizeWithAncestors();
+    template <typename T> bool operator()(const T &a, const T &b) const {
+        double a_mod_fee, a_size, b_mod_fee, b_size;
 
-        double bFees = b.GetModFeesWithAncestors() / SATOSHI;
-        double bSize = b.GetSizeWithAncestors();
+        GetModFeeAndSize(a, a_mod_fee, a_size);
+        GetModFeeAndSize(b, b_mod_fee, b_size);
 
         // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
-        double f1 = aFees * bSize;
-        double f2 = aSize * bFees;
+        double f1 = a_mod_fee * b_size;
+        double f2 = a_size * b_mod_fee;
 
         if (f1 == f2) {
             return a.GetTx().GetId() < b.GetTx().GetId();
         }
-
         return f1 > f2;
     }
+
+    // Return the fee/size we're using for sorting this entry.
+    template <typename T>
+    void GetModFeeAndSize(const T &a, double &mod_fee, double &size) const {
+        // Compare feerate with ancestors to feerate of the transaction, and
+        // return the fee/size for the min.
+        double f1 = a.GetSizeWithAncestors() * (a.GetModifiedFee() / SATOSHI);
+        double f2 = a.GetTxSize() * (a.GetModFeesWithAncestors() / SATOSHI);
+
+        if (f1 > f2) {
+            mod_fee = a.GetModFeesWithAncestors() / SATOSHI;
+            size = a.GetSizeWithAncestors();
+        } else {
+            mod_fee = a.GetModifiedFee() / SATOSHI;
+            size = a.GetTxSize();
+        }
+    }
 };
 
 // Multi_index tag names
 struct descendant_score {};
 struct entry_time {};
 struct ancestor_score {};
 
 /**
  * Information about a mempool transaction.
  */
 struct TxMempoolInfo {
     /** The transaction itself */
     CTransactionRef tx;
 
     /** Time the transaction entered the mempool. */
     int64_t nTime;
 
     /** Feerate of the transaction. */
     CFeeRate feeRate;
 
     /** The fee delta. */
     Amount nFeeDelta;
 };
 
 /**
  * Reason why a transaction was removed from the mempool, this is passed to the
  * notification signal.
  */
 enum class MemPoolRemovalReason {
     //! Manually removed or unknown reason
     UNKNOWN = 0,
     //! Expired from mempool
     EXPIRY,
     //! Removed in size limiting
     SIZELIMIT,
     //! Removed for reorganization
     REORG,
     //! Removed for block
     BLOCK,
     //! Removed for conflict with in-block transaction
     CONFLICT,
     //! Removed for replacement
     REPLACED
 };
 
 class SaltedTxidHasher {
 private:
     /** Salt */
     const uint64_t k0, k1;
 
 public:
     SaltedTxidHasher();
 
     size_t operator()(const uint256 &txid) const {
         return SipHashUint256(k0, k1, txid);
     }
 };
 
 typedef std::pair<double, Amount> TXModifier;
 
 /**
  * CTxMemPool stores valid-according-to-the-current-best-chain transactions that
  * may be included in the next block.
  *
  * Transactions are added when they are seen on the network (or created by the
  * local node), but not all transactions seen are added to the pool. For
  * example, the following new transactions will not be added to the mempool:
  * - a transaction which doesn't meet the minimum fee requirements.
  * - a new transaction that double-spends an input of a transaction already in
  * the pool where the new transaction does not meet the Replace-By-Fee
  * requirements as defined in BIP 125.
  * - a non-standard transaction.
  *
  * CTxMemPool::mapTx, and CTxMemPoolEntry bookkeeping:
  *
  * mapTx is a boost::multi_index that sorts the mempool on 4 criteria:
  * - transaction hash
  * - feerate [we use max(feerate of tx, feerate of tx with all descendants)]
  * - time in mempool
  *
  * Note: the term "descendant" refers to in-mempool transactions that depend on
  * this one, while "ancestor" refers to in-mempool transactions that a given
  * transaction depends on.
  *
  * In order for the feerate sort to remain correct, we must update transactions
  * in the mempool when new descendants arrive. To facilitate this, we track the
  * set of in-mempool direct parents and direct children in mapLinks. Within each
  * CTxMemPoolEntry, we track the size and fees of all descendants.
  *
  * Usually when a new transaction is added to the mempool, it has no in-mempool
  * children (because any such children would be an orphan). So in
  * addUnchecked(), we:
  * - update a new entry's setMemPoolParents to include all in-mempool parents
  * - update the new entry's direct parents to include the new tx as a child
  * - update all ancestors of the transaction to include the new tx's size/fee
  *
  * When a transaction is removed from the mempool, we must:
  * - update all in-mempool parents to not track the tx in setMemPoolChildren
  * - update all ancestors to not include the tx's size/fees in descendant state
  * - update all in-mempool children to not include it as a parent
  *
  * These happen in UpdateForRemoveFromMempool(). (Note that when removing a
  * transaction along with its descendants, we must calculate that set of
  * transactions to be removed before doing the removal, or else the mempool can
  * be in an inconsistent state where it's impossible to walk the ancestors of a
  * transaction.)
  *
  * In the event of a reorg, the assumption that a newly added tx has no
  * in-mempool children is false.  In particular, the mempool is in an
  * inconsistent state while new transactions are being added, because there may
  * be descendant transactions of a tx coming from a disconnected block that are
  * unreachable from just looking at transactions in the mempool (the linking
  * transactions may also be in the disconnected block, waiting to be added).
  * Because of this, there's not much benefit in trying to search for in-mempool
  * children in addUnchecked(). Instead, in the special case of transactions
  * being added from a disconnected block, we require the caller to clean up the
  * state, to account for in-mempool, out-of-block descendants for all the
  * in-block transactions by calling UpdateTransactionsFromBlock(). Note that
  * until this is called, the mempool state is not consistent, and in particular
  * mapLinks may not be correct (and therefore functions like
  * CalculateMemPoolAncestors() and CalculateDescendants() that rely on them to
  * walk the mempool are not generally safe to use).
  *
  * Computational limits:
  *
  * Updating all in-mempool ancestors of a newly added transaction can be slow,
  * if no bound exists on how many in-mempool ancestors there may be.
  * CalculateMemPoolAncestors() takes configurable limits that are designed to
  * prevent these calculations from being too CPU intensive.
  */
 class CTxMemPool {
 private:
     //!< Value n means that n times in 2^32 we check.
     uint32_t nCheckFrequency GUARDED_BY(cs);
     //!< Used by getblocktemplate to trigger CreateNewBlock() invocation
     unsigned int nTransactionsUpdated;
 
     //!< sum of all mempool tx's virtual sizes.
     uint64_t totalTxSize;
     //!< sum of dynamic memory usage of all the map elements (NOT the maps
     //! themselves)
     uint64_t cachedInnerUsage;
 
     mutable int64_t lastRollingFeeUpdate;
     mutable bool blockSinceLastRollingFeeBump;
     //!< minimum fee to get into the pool, decreases exponentially
     mutable double rollingMinimumFeeRate;
 
     void trackPackageRemoved(const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
 public:
     // public only for testing
     static const int ROLLING_FEE_HALFLIFE = 60 * 60 * 12;
 
     typedef boost::multi_index_container<
         CTxMemPoolEntry, boost::multi_index::indexed_by<
                              // sorted by txid
                              boost::multi_index::hashed_unique<
                                  mempoolentry_txid, SaltedTxidHasher>,
                              // sorted by fee rate
                              boost::multi_index::ordered_non_unique<
                                  boost::multi_index::tag<descendant_score>,
                                  boost::multi_index::identity<CTxMemPoolEntry>,
                                  CompareTxMemPoolEntryByDescendantScore>,
                              // sorted by entry time
                              boost::multi_index::ordered_non_unique<
                                  boost::multi_index::tag<entry_time>,
                                  boost::multi_index::identity<CTxMemPoolEntry>,
                                  CompareTxMemPoolEntryByEntryTime>,
                              // sorted by fee rate with ancestors
                              boost::multi_index::ordered_non_unique<
                                  boost::multi_index::tag<ancestor_score>,
                                  boost::multi_index::identity<CTxMemPoolEntry>,
                                  CompareTxMemPoolEntryByAncestorFee>>>
         indexed_transaction_set;
 
     mutable CCriticalSection cs;
     indexed_transaction_set mapTx GUARDED_BY(cs);
 
     typedef indexed_transaction_set::nth_index<0>::type::iterator txiter;
     //!< All tx hashes/entries in mapTx, in random order
     std::vector<std::pair<uint256, txiter>> vTxHashes;
 
     struct CompareIteratorByHash {
         bool operator()(const txiter &a, const txiter &b) const {
             return a->GetTx().GetId() < b->GetTx().GetId();
         }
     };
     typedef std::set<txiter, CompareIteratorByHash> setEntries;
 
     const setEntries &GetMemPoolParents(txiter entry) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     const setEntries &GetMemPoolChildren(txiter entry) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     uint64_t CalculateDescendantMaximum(txiter entry) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
 private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
 
     struct TxLinks {
         setEntries parents;
         setEntries children;
     };
 
     typedef std::map<txiter, TxLinks, CompareIteratorByHash> txlinksMap;
     txlinksMap mapLinks;
 
     void UpdateParent(txiter entry, txiter parent, bool add);
     void UpdateChild(txiter entry, txiter child, bool add);
 
     std::vector<indexed_transaction_set::const_iterator>
     GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
 public:
     indirectmap<COutPoint, const CTransaction *> mapNextTx GUARDED_BY(cs);
     std::map<uint256, TXModifier> mapDeltas;
 
     /**
      * Create a new CTxMemPool.
      */
     CTxMemPool();
     ~CTxMemPool();
 
     /**
      * If sanity-checking is turned on, check makes sure the pool is consistent
      * (does not contain two transactions that spend the same inputs, all inputs
      * are in the mapNextTx array). If sanity-checking is turned off, check does
      * nothing.
      */
     void check(const CCoinsViewCache *pcoins) const;
     void setSanityCheck(double dFrequency = 1.0) {
         LOCK(cs);
         nCheckFrequency = static_cast<uint32_t>(dFrequency * 4294967295.0);
     }
 
     // addUnchecked must updated state for all ancestors of a given transaction,
     // to track size/count of descendant transactions. First version of
     // addUnchecked can be used to have it call CalculateMemPoolAncestors(), and
     // then invoke the second version.
     // Note that addUnchecked is ONLY called from ATMP outside of tests
     // and any other callers may break wallet's in-mempool tracking (due to
     // lack of CValidationInterface::TransactionAddedToMempool callbacks).
     bool addUnchecked(const uint256 &hash, const CTxMemPoolEntry &entry);
     bool addUnchecked(const uint256 &hash, const CTxMemPoolEntry &entry,
                       setEntries &setAncestors);
 
     void removeRecursive(
         const CTransaction &tx,
         MemPoolRemovalReason reason = MemPoolRemovalReason::UNKNOWN);
     void removeForReorg(const Config &config, const CCoinsViewCache *pcoins,
                         unsigned int nMemPoolHeight, int flags);
     void removeConflicts(const CTransaction &tx);
     void removeForBlock(const std::vector<CTransactionRef> &vtx,
                         unsigned int nBlockHeight);
 
     void clear();
     // lock free
     void _clear() EXCLUSIVE_LOCKS_REQUIRED(cs);
     bool CompareDepthAndScore(const uint256 &hasha, const uint256 &hashb);
     void queryHashes(std::vector<uint256> &vtxid);
     bool isSpent(const COutPoint &outpoint) const;
     unsigned int GetTransactionsUpdated() const;
     void AddTransactionsUpdated(unsigned int n);
     /**
      * Check that none of this transactions inputs are in the mempool, and thus
      * the tx is not dependent on other mempool transactions to be included in a
      * block.
      */
     bool HasNoInputsOf(const CTransaction &tx) const;
 
     /** Affect CreateNewBlock prioritisation of transactions */
     void PrioritiseTransaction(const uint256 &hash, double dPriorityDelta,
                                const Amount nFeeDelta);
     void ApplyDeltas(const uint256 hash, double &dPriorityDelta,
                      Amount &nFeeDelta) const;
     void ClearPrioritisation(const uint256 hash);
 
 public:
     /**
      * Remove a set of transactions from the mempool. If a transaction is in
      * this set, then all in-mempool descendants must also be in the set, unless
      * this transaction is being removed for being in a block. Set
      * updateDescendants to true when removing a tx that was in a block, so that
      * any in-mempool descendants have their ancestor state updated.
      */
     void
     RemoveStaged(setEntries &stage, bool updateDescendants,
                  MemPoolRemovalReason reason = MemPoolRemovalReason::UNKNOWN)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * When adding transactions from a disconnected block back to the mempool,
      * new mempool entries may have children in the mempool (which is generally
      * not the case when otherwise adding transactions).
      * UpdateTransactionsFromBlock() will find child transactions and update the
      * descendant state for each transaction in txidsToUpdate (excluding any
      * child transactions present in txidsToUpdate, which are already accounted
      * for).
      * Note: txidsToUpdate should be the set of transactions from the
      * disconnected block that have been accepted back into the mempool.
      */
     void UpdateTransactionsFromBlock(const std::vector<TxId> &txidsToUpdate);
 
     /**
      * Try to calculate all in-mempool ancestors of entry.
      *  (these are all calculated including the tx itself)
      *  limitAncestorCount = max number of ancestors
      *  limitAncestorSize = max size of ancestors
      *  limitDescendantCount = max number of descendants any ancestor can have
      *  limitDescendantSize = max size of descendants any ancestor can have
      *  errString = populated with error reason if any limits are hit
      * fSearchForParents = whether to search a tx's vin for in-mempool parents,
      * or look up parents from mapLinks. Must be true for entries not in the
      * mempool
      */
     bool CalculateMemPoolAncestors(
         const CTxMemPoolEntry &entry, setEntries &setAncestors,
         uint64_t limitAncestorCount, uint64_t limitAncestorSize,
         uint64_t limitDescendantCount, uint64_t limitDescendantSize,
         std::string &errString, bool fSearchForParents = true) const;
 
     /**
      * Populate setDescendants with all in-mempool descendants of hash.
      * Assumes that setDescendants includes all in-mempool descendants of
      * anything already in it.
      */
     void CalculateDescendants(txiter it, setEntries &setDescendants) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * The minimum fee to get into the mempool, which may itself not be enough
      * for larger-sized transactions. The incrementalRelayFee policy variable is
      * used to bound the time it takes the fee rate to go back down all the way
      * to 0. When the feerate would otherwise be half of this, it is set to 0
      * instead.
      */
     CFeeRate GetMinFee(size_t sizelimit) const;
 
     /**
      * Remove transactions from the mempool until its dynamic size is <=
      * sizelimit. pvNoSpendsRemaining, if set, will be populated with the list
      * of outpoints which are not in mempool which no longer have any spends in
      * this mempool.
      */
     void TrimToSize(size_t sizelimit,
                     std::vector<COutPoint> *pvNoSpendsRemaining = nullptr);
 
     /**
      * Expire all transaction (and their dependencies) in the mempool older than
      * time. Return the number of removed transactions.
      */
     int Expire(int64_t time);
 
     /**
      * Reduce the size of the mempool by expiring and then trimming the mempool.
      */
     void LimitSize(size_t limit, unsigned long age);
 
     /**
      * Calculate the ancestor and descendant count for the given transaction.
      * The counts include the transaction itself.
      */
     void GetTransactionAncestry(const uint256 &txid, size_t &ancestors,
                                 size_t &descendants) const;
 
     unsigned long size() {
         LOCK(cs);
         return mapTx.size();
     }
 
     uint64_t GetTotalTxSize() const {
         LOCK(cs);
         return totalTxSize;
     }
 
     bool exists(uint256 hash) const {
         LOCK(cs);
         return mapTx.count(hash) != 0;
     }
 
     CTransactionRef get(const uint256 &hash) const;
     TxMempoolInfo info(const uint256 &hash) const;
     std::vector<TxMempoolInfo> infoAll() const;
 
     CFeeRate estimateFee() const;
 
     size_t DynamicMemoryUsage() const;
 
     boost::signals2::signal<void(CTransactionRef)> NotifyEntryAdded;
     boost::signals2::signal<void(CTransactionRef, MemPoolRemovalReason)>
         NotifyEntryRemoved;
 
 private:
     /**
      * UpdateForDescendants is used by UpdateTransactionsFromBlock to update the
      * descendants for a single transaction that has been added to the mempool
      * but may have child transactions in the mempool, eg during a chain reorg.
      * setExclude is the set of descendant transactions in the mempool that must
      * not be accounted for (because any descendants in setExclude were added to
      * the mempool after the transaction being updated and hence their state is
      * already reflected in the parent state).
      *
      * cachedDescendants will be updated with the descendants of the transaction
      * being updated, so that future invocations don't need to walk the same
      * transaction again, if encountered in another transaction chain.
      */
     void UpdateForDescendants(txiter updateIt, cacheMap &cachedDescendants,
                               const std::set<TxId> &setExclude)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     /**
      * Update ancestors of hash to add/remove it as a descendant transaction.
      */
     void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** Set ancestor state for an entry */
     void UpdateEntryForAncestors(txiter it, const setEntries &setAncestors)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     /**
      * For each transaction being removed, update ancestors and any direct
      * children. If updateDescendants is true, then also update in-mempool
      * descendants' ancestor state.
      */
     void UpdateForRemoveFromMempool(const setEntries &entriesToRemove,
                                     bool updateDescendants)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** Sever link between specified transaction and direct children. */
     void UpdateChildrenForRemoval(txiter entry) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Before calling removeUnchecked for a given transaction,
      * UpdateForRemoveFromMempool must be called on the entire (dependent) set
      * of transactions being removed at the same time. We use each
      * CTxMemPoolEntry's setMemPoolParents in order to walk ancestors of a given
      * transaction that is removed, so we can't remove intermediate transactions
      * in a chain before we've updated all the state for the removal.
      */
     void
     removeUnchecked(txiter entry,
                     MemPoolRemovalReason reason = MemPoolRemovalReason::UNKNOWN)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 };
 
 /**
  * CCoinsView that brings transactions from a memorypool into view.
  * It does not check for spendings by memory pool transactions.
  * Instead, it provides access to all Coins which are either unspent in the
  * base CCoinsView, or are outputs from any mempool transaction!
  * This allows transaction replacement to work as expected, as you want to
  * have all inputs "available" to check signatures, and any cycles in the
  * dependency graph are checked directly in AcceptToMemoryPool.
  * It also allows you to sign a double-spend directly in signrawtransaction,
  * as long as the conflicting transaction is not yet confirmed.
  */
 class CCoinsViewMemPool : public CCoinsViewBacked {
 protected:
     const CTxMemPool &mempool;
 
 public:
     CCoinsViewMemPool(CCoinsView *baseIn, const CTxMemPool &mempoolIn);
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
 };
 
 // We want to sort transactions by coin age priority
 typedef std::pair<double, CTxMemPool::txiter> TxCoinAgePriority;
 
 struct TxCoinAgePriorityCompare {
     bool operator()(const TxCoinAgePriority &a, const TxCoinAgePriority &b) {
         if (a.first == b.first) {
             // Reverse order to make sort less than
             return CompareTxMemPoolEntryByScore()(*(b.second), *(a.second));
         }
         return a.first < b.first;
     }
 };
 
 /**
  * DisconnectedBlockTransactions
  *
  * During the reorg, it's desirable to re-add previously confirmed transactions
  * to the mempool, so that anything not re-confirmed in the new chain is
  * available to be mined. However, it's more efficient to wait until the reorg
  * is complete and process all still-unconfirmed transactions at that time,
  * since we expect most confirmed transactions to (typically) still be
  * confirmed in the new chain, and re-accepting to the memory pool is expensive
  * (and therefore better to not do in the middle of reorg-processing).
  * Instead, store the disconnected transactions (in order!) as we go, remove any
  * that are included in blocks in the new chain, and then process the remaining
  * still-unconfirmed transactions at the end.
  *
  * It also enables efficient reprocessing of current mempool entries, useful
  * when (de)activating forks that result in in-mempool transactions becoming
  * invalid
  */
 // multi_index tag names
 struct txid_index {};
 struct insertion_order {};
 
 class DisconnectedBlockTransactions {
 private:
     typedef boost::multi_index_container<
         CTransactionRef, boost::multi_index::indexed_by<
                              // sorted by txid
                              boost::multi_index::hashed_unique<
                                  boost::multi_index::tag<txid_index>,
                                  mempoolentry_txid, SaltedTxidHasher>,
                              // sorted by order in the blockchain
                              boost::multi_index::sequenced<
                                  boost::multi_index::tag<insertion_order>>>>
         indexed_disconnected_transactions;
 
     indexed_disconnected_transactions queuedTx;
     uint64_t cachedInnerUsage = 0;
 
     void addTransaction(const CTransactionRef &tx) {
         queuedTx.insert(tx);
         cachedInnerUsage += RecursiveDynamicUsage(tx);
     }
 
 public:
     // It's almost certainly a logic bug if we don't clear out queuedTx before
     // destruction, as we add to it while disconnecting blocks, and then we
     // need to re-process remaining transactions to ensure mempool consistency.
     // For now, assert() that we've emptied out this object on destruction.
     // This assert() can always be removed if the reorg-processing code were
     // to be refactored such that this assumption is no longer true (for
     // instance if there was some other way we cleaned up the mempool after a
     // reorg, besides draining this object).
     ~DisconnectedBlockTransactions() { assert(queuedTx.empty()); }
 
     // Estimate the overhead of queuedTx to be 6 pointers + an allocation, as
     // no exact formula for boost::multi_index_contained is implemented.
     size_t DynamicMemoryUsage() const {
         return memusage::MallocUsage(sizeof(CTransactionRef) +
                                      6 * sizeof(void *)) *
                    queuedTx.size() +
                cachedInnerUsage;
     }
 
     const indexed_disconnected_transactions &GetQueuedTx() const {
         return queuedTx;
     }
 
     // Import mempool entries in topological order into queuedTx and clear the
     // mempool. Caller should call updateMempoolForReorg to reprocess these
     // transactions
     void importMempool(CTxMemPool &pool);
 
     // Add entries for a block while reconstructing the topological ordering so
     // they can be added back to the mempool simply.
     void addForBlock(const std::vector<CTransactionRef> &vtx);
 
     // Remove entries based on txid_index, and update memory usage.
     void removeForBlock(const std::vector<CTransactionRef> &vtx) {
         // Short-circuit in the common case of a block being added to the tip
         if (queuedTx.empty()) {
             return;
         }
         for (auto const &tx : vtx) {
             auto it = queuedTx.find(tx->GetId());
             if (it != queuedTx.end()) {
                 cachedInnerUsage -= RecursiveDynamicUsage(*it);
                 queuedTx.erase(it);
             }
         }
     }
 
     // Remove an entry by insertion_order index, and update memory usage.
     void removeEntry(indexed_disconnected_transactions::index<
                      insertion_order>::type::iterator entry) {
         cachedInnerUsage -= RecursiveDynamicUsage(*entry);
         queuedTx.get<insertion_order>().erase(entry);
     }
 
     bool isEmpty() const { return queuedTx.empty(); }
 
     void clear() {
         cachedInnerUsage = 0;
         queuedTx.clear();
     }
 
     /**
      * Make mempool consistent after a reorg, by re-adding or recursively
      * erasing disconnected block transactions from the mempool, and also
      * removing any other transactions from the mempool that are no longer valid
      * given the new tip/height.
      *
      * Note: we assume that disconnectpool only contains transactions that are
      * NOT confirmed in the current chain nor already in the mempool (otherwise,
      * in-mempool descendants of such transactions would be removed).
      *
      * Passing fAddToMempool=false will skip trying to add the transactions
      * back, and instead just erase from the mempool as needed.
      */
     void updateMempoolForReorg(const Config &config, bool fAddToMempool);
 };
 
 #endif // BITCOIN_TXMEMPOOL_H