src/txmempool.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "txmempool.h"
   7
   8 #include "clientversion.h"
   9 #include "consensus/consensus.h"
  10 #include "consensus/validation.h"
  11 #include "main.h"
  12 #include "policy/fees.h"
  13 #include "streams.h"
  14 #include "timedata.h"
  15 #include "util.h"
  16 #include "utilmoneystr.h"
  17 #include "version.h"
  18
  19 using namespace std;
  20
  21 CTxMemPoolEntry::CTxMemPoolEntry():
  22     nFee(0), nTxSize(0), nModSize(0), nUsageSize(0), nTime(0), dPriority(0.0),
  23     hadNoDependencies(false), spendsCoinbase(false)
  24 {
  25     nHeight = MEMPOOL_HEIGHT;
  26 }
  27
  28 CTxMemPoolEntry::CTxMemPoolEntry(const CTransaction& _tx, const CAmount& _nFee,
  29                                  int64_t _nTime, double _dPriority,
  30                                  unsigned int _nHeight, bool poolHasNoInputsOf,
  31                                  bool _spendsCoinbase, uint32_t _nBranchId):
  32     tx(_tx), nFee(_nFee), nTime(_nTime), dPriority(_dPriority), nHeight(_nHeight),
  33     hadNoDependencies(poolHasNoInputsOf),
  34     spendsCoinbase(_spendsCoinbase), nBranchId(_nBranchId)
  35 {
  36     nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
  37     nModSize = tx.CalculateModifiedSize(nTxSize);
  38     nUsageSize = RecursiveDynamicUsage(tx);
  39     feeRate = CFeeRate(nFee, nTxSize);
  40 }
  41
  42 CTxMemPoolEntry::CTxMemPoolEntry(const CTxMemPoolEntry& other)
  43 {
  44     *this = other;
  45 }
  46
  47 double
  48 CTxMemPoolEntry::GetPriority(unsigned int currentHeight) const
  49 {
  50     CAmount nValueIn = tx.GetValueOut()+nFee;
  51     double deltaPriority = ((double)(currentHeight-nHeight)*nValueIn)/nModSize;
  52     double dResult = dPriority + deltaPriority;
  53     return dResult;
  54 }
  55
  56 CTxMemPool::CTxMemPool(const CFeeRate& _minRelayFee) :
  57     nTransactionsUpdated(0)
  58 {
  59     // Sanity checks off by default for performance, because otherwise
  60     // accepting transactions becomes O(N^2) where N is the number
  61     // of transactions in the pool
  62     nCheckFrequency = 0;
  63
  64     minerPolicyEstimator = new CBlockPolicyEstimator(_minRelayFee);
  65 }
  66
  67 CTxMemPool::~CTxMemPool()
  68 {
  69     delete minerPolicyEstimator;
  70 }
  71
  72 void CTxMemPool::pruneSpent(const uint256 &hashTx, CCoins &coins)
  73 {
  74     LOCK(cs);
  75
  76     std::map<COutPoint, CInPoint>::iterator it = mapNextTx.lower_bound(COutPoint(hashTx, 0));
  77
  78     // iterate over all COutPoints in mapNextTx whose hash equals the provided hashTx
  79     while (it != mapNextTx.end() && it->first.hash == hashTx) {
  80         coins.Spend(it->first.n); // and remove those outputs from coins
  81         it++;
  82     }
  83 }
  84
  85 unsigned int CTxMemPool::GetTransactionsUpdated() const
  86 {
  87     LOCK(cs);
  88     return nTransactionsUpdated;
  89 }
  90
  91 void CTxMemPool::AddTransactionsUpdated(unsigned int n)
  92 {
  93     LOCK(cs);
  94     nTransactionsUpdated += n;
  95 }
  96
  97
  98 bool CTxMemPool::addUnchecked(const uint256& hash, const CTxMemPoolEntry &entry, bool fCurrentEstimate)
  99 {
 100     // Add to memory pool without checking anything.
 101     // Used by main.cpp AcceptToMemoryPool(), which DOES do
 102     // all the appropriate checks.
 103     LOCK(cs);
 104     mapTx.insert(entry);
 105     const CTransaction& tx = mapTx.find(hash)->GetTx();
 106     for (unsigned int i = 0; i < tx.vin.size(); i++)
 107         mapNextTx[tx.vin[i].prevout] = CInPoint(&tx, i);
 108     BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
 109         BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
 110             mapSproutNullifiers[nf] = &tx;
 111         }
 112     }
 113     for (const SpendDescription &spendDescription : tx.vShieldedSpend) {
 114         mapSaplingNullifiers[spendDescription.nullifier] = &tx;
 115     }
 116     nTransactionsUpdated++;
 117     totalTxSize += entry.GetTxSize();
 118     cachedInnerUsage += entry.DynamicMemoryUsage();
 119     minerPolicyEstimator->processTransaction(entry, fCurrentEstimate);
 120
 121     return true;
 122 }
 123
 124
 125 void CTxMemPool::remove(const CTransaction &origTx, std::list<CTransaction>& removed, bool fRecursive)
 126 {
 127     // Remove transaction from memory pool
 128     {
 129         LOCK(cs);
 130         std::deque<uint256> txToRemove;
 131         txToRemove.push_back(origTx.GetHash());
 132         if (fRecursive && !mapTx.count(origTx.GetHash())) {
 133             // If recursively removing but origTx isn't in the mempool
 134             // be sure to remove any children that are in the pool. This can
 135             // happen during chain re-orgs if origTx isn't re-accepted into
 136             // the mempool for any reason.
 137             for (unsigned int i = 0; i < origTx.vout.size(); i++) {
 138                 std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(COutPoint(origTx.GetHash(), i));
 139                 if (it == mapNextTx.end())
 140                     continue;
 141                 txToRemove.push_back(it->second.ptx->GetHash());
 142             }
 143         }
 144         while (!txToRemove.empty())
 145         {
 146             uint256 hash = txToRemove.front();
 147             txToRemove.pop_front();
 148             if (!mapTx.count(hash))
 149                 continue;
 150             const CTransaction& tx = mapTx.find(hash)->GetTx();
 151             if (fRecursive) {
 152                 for (unsigned int i = 0; i < tx.vout.size(); i++) {
 153                     std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(COutPoint(hash, i));
 154                     if (it == mapNextTx.end())
 155                         continue;
 156                     txToRemove.push_back(it->second.ptx->GetHash());
 157                 }
 158             }
 159             BOOST_FOREACH(const CTxIn& txin, tx.vin)
 160                 mapNextTx.erase(txin.prevout);
 161             BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit) {
 162                 BOOST_FOREACH(const uint256& nf, joinsplit.nullifiers) {
 163                     mapSproutNullifiers.erase(nf);
 164                 }
 165             }
 166             for (const SpendDescription &spendDescription : tx.vShieldedSpend) {
 167                 mapSaplingNullifiers.erase(spendDescription.nullifier);
 168             }
 169             removed.push_back(tx);
 170             totalTxSize -= mapTx.find(hash)->GetTxSize();
 171             cachedInnerUsage -= mapTx.find(hash)->DynamicMemoryUsage();
 172             mapTx.erase(hash);
 173             nTransactionsUpdated++;
 174             minerPolicyEstimator->removeTx(hash);
 175         }
 176     }
 177 }
 178
 179 void CTxMemPool::removeForReorg(const CCoinsViewCache *pcoins, unsigned int nMemPoolHeight, int flags)
 180 {
 181     // Remove transactions spending a coinbase which are now immature and no-longer-final transactions
 182     LOCK(cs);
 183     list<CTransaction> transactionsToRemove;
 184     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
 185         const CTransaction& tx = it->GetTx();
 186         if (!CheckFinalTx(tx, flags)) {
 187             transactionsToRemove.push_back(tx);
 188         } else if (it->GetSpendsCoinbase()) {
 189             BOOST_FOREACH(const CTxIn& txin, tx.vin) {
 190                 indexed_transaction_set::const_iterator it2 = mapTx.find(txin.prevout.hash);
 191                 if (it2 != mapTx.end())
 192                     continue;
 193                 const CCoins *coins = pcoins->AccessCoins(txin.prevout.hash);
 194                 if (nCheckFrequency != 0) assert(coins);
 195                 if (!coins || (coins->IsCoinBase() && ((signed long)nMemPoolHeight) - coins->nHeight < COINBASE_MATURITY)) {
 196                     transactionsToRemove.push_back(tx);
 197                     break;
 198                 }
 199             }
 200         }
 201     }
 202     BOOST_FOREACH(const CTransaction& tx, transactionsToRemove) {
 203         list<CTransaction> removed;
 204         remove(tx, removed, true);
 205     }
 206 }
 207
 208
 209 void CTxMemPool::removeWithAnchor(const uint256 &invalidRoot, ShieldedType type)
 210 {
 211     // If a block is disconnected from the tip, and the root changed,
 212     // we must invalidate transactions from the mempool which spend
 213     // from that root -- almost as though they were spending coinbases
 214     // which are no longer valid to spend due to coinbase maturity.
 215     LOCK(cs);
 216     list<CTransaction> transactionsToRemove;
 217
 218     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
 219         const CTransaction& tx = it->GetTx();
 220         switch (type) {
 221             case SPROUT:
 222                 BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit) {
 223                     if (joinsplit.anchor == invalidRoot) {
 224                         transactionsToRemove.push_back(tx);
 225                         break;
 226                     }
 227                 }
 228             break;
 229             case SAPLING:
 230                 BOOST_FOREACH(const SpendDescription& spendDescription, tx.vShieldedSpend) {
 231                     if (spendDescription.anchor == invalidRoot) {
 232                         transactionsToRemove.push_back(tx);
 233                         break;
 234                     }
 235                 }
 236             break;
 237             default:
 238                 throw runtime_error("Unknown shielded type");
 239             break;
 240         }
 241     }
 242
 243     BOOST_FOREACH(const CTransaction& tx, transactionsToRemove) {
 244         list<CTransaction> removed;
 245         remove(tx, removed, true);
 246     }
 247 }
 248
 249 void CTxMemPool::removeConflicts(const CTransaction &tx, std::list<CTransaction>& removed)
 250 {
 251     // Remove transactions which depend on inputs of tx, recursively
 252     list<CTransaction> result;
 253     LOCK(cs);
 254     BOOST_FOREACH(const CTxIn &txin, tx.vin) {
 255         std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(txin.prevout);
 256         if (it != mapNextTx.end()) {
 257             const CTransaction &txConflict = *it->second.ptx;
 258             if (txConflict != tx)
 259             {
 260                 remove(txConflict, removed, true);
 261             }
 262         }
 263     }
 264
 265     BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
 266         BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
 267             std::map<uint256, const CTransaction*>::iterator it = mapSproutNullifiers.find(nf);
 268             if (it != mapSproutNullifiers.end()) {
 269                 const CTransaction &txConflict = *it->second;
 270                 if (txConflict != tx) {
 271                     remove(txConflict, removed, true);
 272                 }
 273             }
 274         }
 275     }
 276     for (const SpendDescription &spendDescription : tx.vShieldedSpend) {
 277         std::map<uint256, const CTransaction*>::iterator it = mapSaplingNullifiers.find(spendDescription.nullifier);
 278         if (it != mapSaplingNullifiers.end()) {
 279             const CTransaction &txConflict = *it->second;
 280             if (txConflict != tx) {
 281                 remove(txConflict, removed, true);
 282             }
 283         }
 284     }
 285 }
 286
 287 void CTxMemPool::removeExpired(unsigned int nBlockHeight)
 288 {
 289     // Remove expired txs from the mempool
 290     LOCK(cs);
 291     list<CTransaction> transactionsToRemove;
 292     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++)
 293     {
 294         const CTransaction& tx = it->GetTx();
 295         if (IsExpiredTx(tx, nBlockHeight)) {
 296             transactionsToRemove.push_back(tx);
 297         }
 298     }
 299     for (const CTransaction& tx : transactionsToRemove) {
 300         list<CTransaction> removed;
 301         remove(tx, removed, true);
 302         LogPrint("mempool", "Removing expired txid: %s\n", tx.GetHash().ToString());
 303     }
 304 }
 305
 306 /**
 307  * Called when a block is connected. Removes from mempool and updates the miner fee estimator.
 308  */
 309 void CTxMemPool::removeForBlock(const std::vector<CTransaction>& vtx, unsigned int nBlockHeight,
 310                                 std::list<CTransaction>& conflicts, bool fCurrentEstimate)
 311 {
 312     LOCK(cs);
 313     std::vector<CTxMemPoolEntry> entries;
 314     BOOST_FOREACH(const CTransaction& tx, vtx)
 315     {
 316         uint256 hash = tx.GetHash();
 317
 318         indexed_transaction_set::iterator i = mapTx.find(hash);
 319         if (i != mapTx.end())
 320             entries.push_back(*i);
 321     }
 322     BOOST_FOREACH(const CTransaction& tx, vtx)
 323     {
 324         std::list<CTransaction> dummy;
 325         remove(tx, dummy, false);
 326         removeConflicts(tx, conflicts);
 327         ClearPrioritisation(tx.GetHash());
 328     }
 329     // After the txs in the new block have been removed from the mempool, update policy estimates
 330     minerPolicyEstimator->processBlock(nBlockHeight, entries, fCurrentEstimate);
 331 }
 332
 333 /**
 334  * Called whenever the tip changes. Removes transactions which don't commit to
 335  * the given branch ID from the mempool.
 336  */
 337 void CTxMemPool::removeWithoutBranchId(uint32_t nMemPoolBranchId)
 338 {
 339     LOCK(cs);
 340     std::list<CTransaction> transactionsToRemove;
 341
 342     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
 343         const CTransaction& tx = it->GetTx();
 344         if (it->GetValidatedBranchId() != nMemPoolBranchId) {
 345             transactionsToRemove.push_back(tx);
 346         }
 347     }
 348
 349     for (const CTransaction& tx : transactionsToRemove) {
 350         std::list<CTransaction> removed;
 351         remove(tx, removed, true);
 352     }
 353 }
 354
 355 void CTxMemPool::clear()
 356 {
 357     LOCK(cs);
 358     mapTx.clear();
 359     mapNextTx.clear();
 360     totalTxSize = 0;
 361     cachedInnerUsage = 0;
 362     ++nTransactionsUpdated;
 363 }
 364
 365 void CTxMemPool::check(const CCoinsViewCache *pcoins) const
 366 {
 367     if (nCheckFrequency == 0)
 368         return;
 369
 370     if (insecure_rand() >= nCheckFrequency)
 371         return;
 372
 373     LogPrint("mempool", "Checking mempool with %u transactions and %u inputs\n", (unsigned int)mapTx.size(), (unsigned int)mapNextTx.size());
 374
 375     uint64_t checkTotal = 0;
 376     uint64_t innerUsage = 0;
 377
 378     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(pcoins));
 379     const int64_t nSpendHeight = GetSpendHeight(mempoolDuplicate);
 380
 381     LOCK(cs);
 382     list<const CTxMemPoolEntry*> waitingOnDependants;
 383     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
 384         unsigned int i = 0;
 385         checkTotal += it->GetTxSize();
 386         innerUsage += it->DynamicMemoryUsage();
 387         const CTransaction& tx = it->GetTx();
 388         bool fDependsWait = false;
 389         BOOST_FOREACH(const CTxIn &txin, tx.vin) {
 390             // Check that every mempool transaction's inputs refer to available coins, or other mempool tx's.
 391             indexed_transaction_set::const_iterator it2 = mapTx.find(txin.prevout.hash);
 392             if (it2 != mapTx.end()) {
 393                 const CTransaction& tx2 = it2->GetTx();
 394                 assert(tx2.vout.size() > txin.prevout.n && !tx2.vout[txin.prevout.n].IsNull());
 395                 fDependsWait = true;
 396             } else {
 397                 const CCoins* coins = pcoins->AccessCoins(txin.prevout.hash);
 398                 assert(coins && coins->IsAvailable(txin.prevout.n));
 399             }
 400             // Check whether its inputs are marked in mapNextTx.
 401             std::map<COutPoint, CInPoint>::const_iterator it3 = mapNextTx.find(txin.prevout);
 402             assert(it3 != mapNextTx.end());
 403             assert(it3->second.ptx == &tx);
 404             assert(it3->second.n == i);
 405             i++;
 406         }
 407
 408         boost::unordered_map<uint256, ZCIncrementalMerkleTree, CCoinsKeyHasher> intermediates;
 409
 410         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
 411             BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
 412                 assert(!pcoins->GetNullifier(nf, SPROUT));
 413             }
 414
 415             ZCIncrementalMerkleTree tree;
 416             auto it = intermediates.find(joinsplit.anchor);
 417             if (it != intermediates.end()) {
 418                 tree = it->second;
 419             } else {
 420                 assert(pcoins->GetSproutAnchorAt(joinsplit.anchor, tree));
 421             }
 422
 423             BOOST_FOREACH(const uint256& commitment, joinsplit.commitments)
 424             {
 425                 tree.append(commitment);
 426             }
 427
 428             intermediates.insert(std::make_pair(tree.root(), tree));
 429         }
 430         for (const SpendDescription &spendDescription : tx.vShieldedSpend) {
 431             ZCSaplingIncrementalMerkleTree tree;
 432
 433             assert(pcoins->GetSaplingAnchorAt(spendDescription.anchor, tree));
 434             assert(!pcoins->GetNullifier(spendDescription.nullifier, SAPLING));
 435         }
 436         if (fDependsWait)
 437             waitingOnDependants.push_back(&(*it));
 438         else {
 439             CValidationState state;
 440             bool fCheckResult = tx.IsCoinBase() ||
 441                 Consensus::CheckTxInputs(tx, state, mempoolDuplicate, nSpendHeight, Params().GetConsensus());
 442             assert(fCheckResult);
 443             UpdateCoins(tx, mempoolDuplicate, 1000000);
 444         }
 445     }
 446     unsigned int stepsSinceLastRemove = 0;
 447     while (!waitingOnDependants.empty()) {
 448         const CTxMemPoolEntry* entry = waitingOnDependants.front();
 449         waitingOnDependants.pop_front();
 450         CValidationState state;
 451         if (!mempoolDuplicate.HaveInputs(entry->GetTx())) {
 452             waitingOnDependants.push_back(entry);
 453             stepsSinceLastRemove++;
 454             assert(stepsSinceLastRemove < waitingOnDependants.size());
 455         } else {
 456             bool fCheckResult = entry->GetTx().IsCoinBase() ||
 457                 Consensus::CheckTxInputs(entry->GetTx(), state, mempoolDuplicate, nSpendHeight, Params().GetConsensus());
 458             assert(fCheckResult);
 459             UpdateCoins(entry->GetTx(), mempoolDuplicate, 1000000);
 460             stepsSinceLastRemove = 0;
 461         }
 462     }
 463     for (std::map<COutPoint, CInPoint>::const_iterator it = mapNextTx.begin(); it != mapNextTx.end(); it++) {
 464         uint256 hash = it->second.ptx->GetHash();
 465         indexed_transaction_set::const_iterator it2 = mapTx.find(hash);
 466         const CTransaction& tx = it2->GetTx();
 467         assert(it2 != mapTx.end());
 468         assert(&tx == it->second.ptx);
 469         assert(tx.vin.size() > it->second.n);
 470         assert(it->first == it->second.ptx->vin[it->second.n].prevout);
 471     }
 472
 473     checkNullifiers(SPROUT);
 474     checkNullifiers(SAPLING);
 475
 476     assert(totalTxSize == checkTotal);
 477     assert(innerUsage == cachedInnerUsage);
 478 }
 479
 480 void CTxMemPool::checkNullifiers(ShieldedType type) const
 481 {
 482     const std::map<uint256, const CTransaction*>* mapToUse;
 483     switch (type) {
 484         case SPROUT:
 485             mapToUse = &mapSproutNullifiers;
 486             break;
 487         case SAPLING:
 488             mapToUse = &mapSaplingNullifiers;
 489             break;
 490         default:
 491             throw runtime_error("Unknown nullifier type");
 492     }
 493     for (const auto& entry : *mapToUse) {
 494         uint256 hash = entry.second->GetHash();
 495         CTxMemPool::indexed_transaction_set::const_iterator findTx = mapTx.find(hash);
 496         const CTransaction& tx = findTx->GetTx();
 497         assert(findTx != mapTx.end());
 498         assert(&tx == entry.second);
 499     }
 500 }
 501
 502 void CTxMemPool::queryHashes(vector<uint256>& vtxid)
 503 {
 504     vtxid.clear();
 505
 506     LOCK(cs);
 507     vtxid.reserve(mapTx.size());
 508     for (indexed_transaction_set::iterator mi = mapTx.begin(); mi != mapTx.end(); ++mi)
 509         vtxid.push_back(mi->GetTx().GetHash());
 510 }
 511
 512 bool CTxMemPool::lookup(uint256 hash, CTransaction& result) const
 513 {
 514     LOCK(cs);
 515     indexed_transaction_set::const_iterator i = mapTx.find(hash);
 516     if (i == mapTx.end()) return false;
 517     result = i->GetTx();
 518     return true;
 519 }
 520
 521 CFeeRate CTxMemPool::estimateFee(int nBlocks) const
 522 {
 523     LOCK(cs);
 524     return minerPolicyEstimator->estimateFee(nBlocks);
 525 }
 526 double CTxMemPool::estimatePriority(int nBlocks) const
 527 {
 528     LOCK(cs);
 529     return minerPolicyEstimator->estimatePriority(nBlocks);
 530 }
 531
 532 bool
 533 CTxMemPool::WriteFeeEstimates(CAutoFile& fileout) const
 534 {
 535     try {
 536         LOCK(cs);
 537         fileout << 109900; // version required to read: 0.10.99 or later
 538         fileout << CLIENT_VERSION; // version that wrote the file
 539         minerPolicyEstimator->Write(fileout);
 540     }
 541     catch (const std::exception&) {
 542         LogPrintf("CTxMemPool::WriteFeeEstimates(): unable to write policy estimator data (non-fatal)\n");
 543         return false;
 544     }
 545     return true;
 546 }
 547
 548 bool
 549 CTxMemPool::ReadFeeEstimates(CAutoFile& filein)
 550 {
 551     try {
 552         int nVersionRequired, nVersionThatWrote;
 553         filein >> nVersionRequired >> nVersionThatWrote;
 554         if (nVersionRequired > CLIENT_VERSION)
 555             return error("CTxMemPool::ReadFeeEstimates(): up-version (%d) fee estimate file", nVersionRequired);
 556
 557         LOCK(cs);
 558         minerPolicyEstimator->Read(filein);
 559     }
 560     catch (const std::exception&) {
 561         LogPrintf("CTxMemPool::ReadFeeEstimates(): unable to read policy estimator data (non-fatal)\n");
 562         return false;
 563     }
 564     return true;
 565 }
 566
 567 void CTxMemPool::PrioritiseTransaction(const uint256 hash, const string strHash, double dPriorityDelta, const CAmount& nFeeDelta)
 568 {
 569     {
 570         LOCK(cs);
 571         std::pair<double, CAmount> &deltas = mapDeltas[hash];
 572         deltas.first += dPriorityDelta;
 573         deltas.second += nFeeDelta;
 574     }
 575     LogPrintf("PrioritiseTransaction: %s priority += %f, fee += %d\n", strHash, dPriorityDelta, FormatMoney(nFeeDelta));
 576 }
 577
 578 void CTxMemPool::ApplyDeltas(const uint256 hash, double &dPriorityDelta, CAmount &nFeeDelta)
 579 {
 580     LOCK(cs);
 581     std::map<uint256, std::pair<double, CAmount> >::iterator pos = mapDeltas.find(hash);
 582     if (pos == mapDeltas.end())
 583         return;
 584     const std::pair<double, CAmount> &deltas = pos->second;
 585     dPriorityDelta += deltas.first;
 586     nFeeDelta += deltas.second;
 587 }
 588
 589 void CTxMemPool::ClearPrioritisation(const uint256 hash)
 590 {
 591     LOCK(cs);
 592     mapDeltas.erase(hash);
 593 }
 594
 595 bool CTxMemPool::HasNoInputsOf(const CTransaction &tx) const
 596 {
 597     for (unsigned int i = 0; i < tx.vin.size(); i++)
 598         if (exists(tx.vin[i].prevout.hash))
 599             return false;
 600     return true;
 601 }
 602
 603 bool CTxMemPool::nullifierExists(const uint256& nullifier, ShieldedType type) const
 604 {
 605     switch (type) {
 606         case SPROUT:
 607             return mapSproutNullifiers.count(nullifier);
 608         case SAPLING:
 609             return mapSaplingNullifiers.count(nullifier);
 610         default:
 611             throw runtime_error("Unknown nullifier type");
 612     }
 613 }
 614
 615 CCoinsViewMemPool::CCoinsViewMemPool(CCoinsView *baseIn, CTxMemPool &mempoolIn) : CCoinsViewBacked(baseIn), mempool(mempoolIn) { }
 616
 617 bool CCoinsViewMemPool::GetNullifier(const uint256 &nf, ShieldedType type) const
 618 {
 619     return mempool.nullifierExists(nf, type) || base->GetNullifier(nf, type);
 620 }
 621
 622 bool CCoinsViewMemPool::GetCoins(const uint256 &txid, CCoins &coins) const {
 623     // If an entry in the mempool exists, always return that one, as it's guaranteed to never
 624     // conflict with the underlying cache, and it cannot have pruned entries (as it contains full)
 625     // transactions. First checking the underlying cache risks returning a pruned entry instead.
 626     CTransaction tx;
 627     if (mempool.lookup(txid, tx)) {
 628         coins = CCoins(tx, MEMPOOL_HEIGHT);
 629         return true;
 630     }
 631     return (base->GetCoins(txid, coins) && !coins.IsPruned());
 632 }
 633
 634 bool CCoinsViewMemPool::HaveCoins(const uint256 &txid) const {
 635     return mempool.exists(txid) || base->HaveCoins(txid);
 636 }
 637
 638 size_t CTxMemPool::DynamicMemoryUsage() const {
 639     LOCK(cs);
 640     // Estimate the overhead of mapTx to be 6 pointers + an allocation, as no exact formula for boost::multi_index_contained is implemented.
 641     return memusage::MallocUsage(sizeof(CTxMemPoolEntry) + 6 * sizeof(void*)) * mapTx.size() + memusage::DynamicUsage(mapNextTx) + memusage::DynamicUsage(mapDeltas) + cachedInnerUsage;
 642 }