diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 99bd123fc..697f9ee18 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1,1614 +1,1614 @@
// 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 <txmempool.h>
#include <chain.h>
#include <chainparams.h> // for GetConsensus.
#include <clientversion.h>
#include <coins.h>
#include <config.h>
#include <consensus/consensus.h>
#include <consensus/tx_verify.h>
#include <consensus/validation.h>
#include <policy/fees.h>
#include <policy/mempool.h>
#include <policy/policy.h>
#include <policy/settings.h>
#include <reverse_iterator.h>
#include <util/moneystr.h>
#include <util/system.h>
#include <util/time.h>
#include <validation.h>
#include <validationinterface.h>
#include <version.h>
#include <algorithm>
#include <cmath>
// 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, int64_t _modifySigChecks)
: modifySize(_modifySize), modifyFee(_modifyFee),
modifyCount(_modifyCount), modifySigChecks(_modifySigChecks) {}
void operator()(CTxMemPoolEntry &e) {
e.UpdateDescendantState(modifySize, modifyFee, modifyCount,
modifySigChecks);
}
private:
int64_t modifySize;
Amount modifyFee;
int64_t modifyCount;
int64_t modifySigChecks;
};
struct update_ancestor_state {
update_ancestor_state(int64_t _modifySize, Amount _modifyFee,
int64_t _modifyCount, int64_t _modifySigChecks)
: modifySize(_modifySize), modifyFee(_modifyFee),
modifyCount(_modifyCount), modifySigChecks(_modifySigChecks) {}
void operator()(CTxMemPoolEntry &e) {
e.UpdateAncestorState(modifySize, modifyFee, modifyCount,
modifySigChecks);
}
private:
int64_t modifySize;
Amount modifyFee;
int64_t modifyCount;
int64_t modifySigChecks;
};
bool TestLockPointValidity(const CChain &active_chain, const LockPoints &lp) {
AssertLockHeld(cs_main);
// If there are relative lock times then the maxInputBlock will be set
// If there are no relative lock times, the LockPoints don't depend on the
// chain
if (lp.maxInputBlock) {
// Check whether active_chain is an extension of the block at which the
// LockPoints calculation was valid. If not LockPoints are no longer
// valid
if (!active_chain.Contains(lp.maxInputBlock)) {
return false;
}
}
// LockPoints still valid
return true;
}
CTxMemPoolEntry::CTxMemPoolEntry(const CTransactionRef &_tx, const Amount fee,
int64_t time, unsigned int entry_height,
bool spends_coinbase, int64_t _sigChecks,
LockPoints lp)
: tx{_tx}, nFee{fee},
nTxSize(tx->GetTotalSize()), nUsageSize{RecursiveDynamicUsage(tx)},
nTime(time), entryHeight{entry_height}, spendsCoinbase(spends_coinbase),
sigChecks(_sigChecks), lockPoints(lp), nSizeWithDescendants{GetTxSize()},
nModFeesWithDescendants{nFee}, nSigChecksWithDescendants{sigChecks},
nSizeWithAncestors{GetTxSize()}, nModFeesWithAncestors{nFee},
nSigChecksWithAncestors{sigChecks} {}
size_t CTxMemPoolEntry::GetTxVirtualSize() const {
return GetVirtualTransactionSize(nTxSize, sigChecks);
}
uint64_t CTxMemPoolEntry::GetVirtualSizeWithDescendants() const {
// note this is distinct from the sum of descendants' individual virtual
// sizes, and may be smaller.
return GetVirtualTransactionSize(nSizeWithDescendants,
nSigChecksWithDescendants);
}
uint64_t CTxMemPoolEntry::GetVirtualSizeWithAncestors() const {
// note this is distinct from the sum of ancestors' individual virtual
// sizes, and may be smaller.
return GetVirtualTransactionSize(nSizeWithAncestors,
nSigChecksWithAncestors);
}
void CTxMemPoolEntry::UpdateFeeDelta(Amount newFeeDelta) {
nModFeesWithDescendants += newFeeDelta - feeDelta;
nModFeesWithAncestors += newFeeDelta - feeDelta;
feeDelta = newFeeDelta;
}
void CTxMemPoolEntry::UpdateLockPoints(const LockPoints &lp) {
lockPoints = lp;
}
void CTxMemPool::UpdateForDescendants(txiter updateIt,
cacheMap &cachedDescendants,
const std::set<TxId> &setExclude,
std::set<TxId> &descendants_to_remove,
uint64_t ancestor_size_limit,
uint64_t ancestor_count_limit) {
CTxMemPoolEntry::Children stageEntries, descendants;
stageEntries = updateIt->GetMemPoolChildrenConst();
while (!stageEntries.empty()) {
const CTxMemPoolEntry &descendant = *stageEntries.begin();
descendants.insert(descendant);
stageEntries.erase(descendant);
const CTxMemPoolEntry::Children &children =
descendant.GetMemPoolChildrenConst();
for (const CTxMemPoolEntry &childEntry : children) {
cacheMap::iterator cacheIt =
cachedDescendants.find(mapTx.iterator_to(childEntry));
if (cacheIt != cachedDescendants.end()) {
// We've already calculated this one, just add the entries for
// this set but don't traverse again.
for (txiter cacheEntry : cacheIt->second) {
descendants.insert(*cacheEntry);
}
} else if (!descendants.count(childEntry)) {
// Schedule for later processing
stageEntries.insert(childEntry);
}
}
}
// descendants now contains all in-mempool descendants of updateIt.
// Update and add to cached descendant map
int64_t modifySize = 0;
int64_t modifyCount = 0;
Amount modifyFee = Amount::zero();
int64_t modifySigChecks = 0;
for (const CTxMemPoolEntry &descendant : descendants) {
if (!setExclude.count(descendant.GetTx().GetId())) {
modifySize += descendant.GetTxSize();
modifyFee += descendant.GetModifiedFee();
modifyCount++;
modifySigChecks += descendant.GetSigChecks();
cachedDescendants[updateIt].insert(mapTx.iterator_to(descendant));
// Update ancestor state for each descendant
mapTx.modify(mapTx.iterator_to(descendant),
update_ancestor_state(updateIt->GetTxSize(),
updateIt->GetModifiedFee(), 1,
updateIt->GetSigChecks()));
// Don't directly remove the transaction here -- doing so would
// invalidate iterators in cachedDescendants. Mark it for removal
// by inserting into descendants_to_remove.
if (descendant.GetCountWithAncestors() > ancestor_count_limit ||
descendant.GetSizeWithAncestors() > ancestor_size_limit) {
descendants_to_remove.insert(descendant.GetTx().GetId());
}
}
}
mapTx.modify(updateIt,
update_descendant_state(modifySize, modifyFee, modifyCount,
modifySigChecks));
}
void CTxMemPool::UpdateTransactionsFromBlock(
const std::vector<TxId> &txidsToUpdate, uint64_t ancestor_size_limit,
uint64_t ancestor_count_limit) {
AssertLockHeld(cs);
// For each entry in txidsToUpdate, store the set of in-mempool, but not
// in-txidsToUpdate transactions, so that we don't have to recalculate
// descendants when we come across a previously seen entry.
cacheMap mapMemPoolDescendantsToUpdate;
// Use a set for lookups into txidsToUpdate (these entries are already
// accounted for in the state of their ancestors)
std::set<TxId> setAlreadyIncluded(txidsToUpdate.begin(),
txidsToUpdate.end());
std::set<TxId> descendants_to_remove;
// Iterate in reverse, so that whenever we are looking at a transaction
// we are sure that all in-mempool descendants have already been processed.
// This maximizes the benefit of the descendant cache and guarantees that
// CTxMemPool::m_children will be updated, an assumption made in
// UpdateForDescendants.
for (const TxId &txid : reverse_iterate(txidsToUpdate)) {
// calculate children from mapNextTx
txiter it = mapTx.find(txid);
if (it == mapTx.end()) {
continue;
}
auto iter = mapNextTx.lower_bound(COutPoint(txid, 0));
// First calculate the children, and update CTxMemPool::m_children to
// include them, and update their CTxMemPoolEntry::m_parents to include
// this tx. we cache the in-mempool children to avoid duplicate updates
{
WITH_FRESH_EPOCH(m_epoch);
for (; iter != mapNextTx.end() && iter->first->GetTxId() == txid;
++iter) {
const TxId &childTxId = iter->second->GetId();
txiter childIter = mapTx.find(childTxId);
assert(childIter != mapTx.end());
// We can skip updating entries we've encountered before or that
// are in the block (which are already accounted for).
if (!visited(childIter) &&
!setAlreadyIncluded.count(childTxId)) {
UpdateChild(it, childIter, true);
UpdateParent(childIter, it, true);
}
}
} // release epoch guard for UpdateForDescendants
UpdateForDescendants(it, mapMemPoolDescendantsToUpdate,
setAlreadyIncluded, descendants_to_remove,
ancestor_size_limit, ancestor_count_limit);
}
for (const auto &txid : descendants_to_remove) {
// This txid may have been removed already in a prior call to
// removeRecursive. Therefore we ensure it is not yet removed already.
if (const std::optional<txiter> txiter = GetIter(txid)) {
removeRecursive((*txiter)->GetTx(),
MemPoolRemovalReason::SIZELIMIT);
}
}
}
bool CTxMemPool::CalculateAncestorsAndCheckLimits(
size_t entry_size, size_t entry_count, setEntries &setAncestors,
CTxMemPoolEntry::Parents &staged_ancestors, uint64_t limitAncestorCount,
uint64_t limitAncestorSize, uint64_t limitDescendantCount,
uint64_t limitDescendantSize, std::string &errString) const {
size_t totalSizeWithAncestors = entry_size;
while (!staged_ancestors.empty()) {
const CTxMemPoolEntry &stage = staged_ancestors.begin()->get();
txiter stageit = mapTx.iterator_to(stage);
setAncestors.insert(stageit);
staged_ancestors.erase(stage);
totalSizeWithAncestors += stageit->GetTxSize();
if (stageit->GetSizeWithDescendants() + entry_size >
limitDescendantSize) {
errString = strprintf(
"exceeds descendant size limit for tx %s [limit: %u]",
stageit->GetTx().GetId().ToString(), limitDescendantSize);
return false;
}
if (stageit->GetCountWithDescendants() + entry_count >
limitDescendantCount) {
errString = strprintf("too many descendants for tx %s [limit: %u]",
stageit->GetTx().GetId().ToString(),
limitDescendantCount);
return false;
}
if (totalSizeWithAncestors > limitAncestorSize) {
errString = strprintf("exceeds ancestor size limit [limit: %u]",
limitAncestorSize);
return false;
}
const CTxMemPoolEntry::Parents &parents =
stageit->GetMemPoolParentsConst();
for (const CTxMemPoolEntry &parent : parents) {
txiter parent_it = mapTx.iterator_to(parent);
// If this is a new ancestor, add it.
if (setAncestors.count(parent_it) == 0) {
staged_ancestors.insert(parent);
}
if (staged_ancestors.size() + setAncestors.size() + entry_count >
limitAncestorCount) {
errString =
strprintf("too many unconfirmed ancestors [limit: %u]",
limitAncestorCount);
return false;
}
}
}
return true;
}
bool CTxMemPool::CheckPackageLimits(const Package &package,
uint64_t limitAncestorCount,
uint64_t limitAncestorSize,
uint64_t limitDescendantCount,
uint64_t limitDescendantSize,
std::string &errString) const {
CTxMemPoolEntry::Parents staged_ancestors;
size_t total_size = 0;
for (const auto &tx : package) {
total_size += GetVirtualTransactionSize(*tx);
for (const auto &input : tx->vin) {
std::optional<txiter> piter = GetIter(input.prevout.GetTxId());
if (piter) {
staged_ancestors.insert(**piter);
if (staged_ancestors.size() + package.size() >
limitAncestorCount) {
errString =
strprintf("too many unconfirmed parents [limit: %u]",
limitAncestorCount);
return false;
}
}
}
}
// When multiple transactions are passed in, the ancestors and descendants
// of all transactions considered together must be within limits even if
// they are not interdependent. This may be stricter than the limits for
// each individual transaction.
setEntries setAncestors;
const auto ret = CalculateAncestorsAndCheckLimits(
total_size, package.size(), setAncestors, staged_ancestors,
limitAncestorCount, limitAncestorSize, limitDescendantCount,
limitDescendantSize, errString);
// It's possible to overestimate the ancestor/descendant totals.
if (!ret) {
errString.insert(0, "possibly ");
}
return ret;
}
bool CTxMemPool::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 {
CTxMemPoolEntry::Parents staged_ancestors;
const CTransaction &tx = entry.GetTx();
if (fSearchForParents) {
// Get parents of this transaction that are in the mempool
// GetMemPoolParents() is only valid for entries in the mempool, so we
// iterate mapTx to find parents.
for (const CTxIn &in : tx.vin) {
std::optional<txiter> piter = GetIter(in.prevout.GetTxId());
if (!piter) {
continue;
}
staged_ancestors.insert(**piter);
if (staged_ancestors.size() + 1 > limitAncestorCount) {
errString =
strprintf("too many unconfirmed parents [limit: %u]",
limitAncestorCount);
return false;
}
}
} else {
// If we're not searching for parents, we require this to be an entry in
// the mempool already.
txiter it = mapTx.iterator_to(entry);
staged_ancestors = it->GetMemPoolParentsConst();
}
return CalculateAncestorsAndCheckLimits(
entry.GetTxSize(), /* entry_count */ 1, setAncestors, staged_ancestors,
limitAncestorCount, limitAncestorSize, limitDescendantCount,
limitDescendantSize, errString);
}
void CTxMemPool::UpdateAncestorsOf(bool add, txiter it,
setEntries &setAncestors) {
const CTxMemPoolEntry::Parents &parents = it->GetMemPoolParentsConst();
// add or remove this tx as a child of each parent
for (const CTxMemPoolEntry &parent : parents) {
UpdateChild(mapTx.iterator_to(parent), it, add);
}
const int64_t updateCount = (add ? 1 : -1);
const int64_t updateSize = updateCount * it->GetTxSize();
const int64_t updateSigChecks = updateCount * it->GetSigChecks();
const Amount updateFee = updateCount * it->GetModifiedFee();
for (txiter ancestorIt : setAncestors) {
mapTx.modify(ancestorIt,
update_descendant_state(updateSize, updateFee, updateCount,
updateSigChecks));
}
}
void CTxMemPool::UpdateEntryForAncestors(txiter it,
const setEntries &setAncestors) {
int64_t updateCount = setAncestors.size();
int64_t updateSize = 0;
int64_t updateSigChecks = 0;
Amount updateFee = Amount::zero();
for (txiter ancestorIt : setAncestors) {
updateSize += ancestorIt->GetTxSize();
updateFee += ancestorIt->GetModifiedFee();
updateSigChecks += ancestorIt->GetSigChecks();
}
mapTx.modify(it, update_ancestor_state(updateSize, updateFee, updateCount,
updateSigChecks));
}
void CTxMemPool::UpdateChildrenForRemoval(txiter it) {
const CTxMemPoolEntry::Children &children = it->GetMemPoolChildrenConst();
for (const CTxMemPoolEntry &updateIt : children) {
UpdateParent(mapTx.iterator_to(updateIt), it, false);
}
}
void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove,
bool updateDescendants) {
// For each entry, walk back all ancestors and decrement size associated
// with this transaction.
const uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
if (updateDescendants) {
// updateDescendants should be true whenever we're not recursively
// removing a tx and all its descendants, eg when a transaction is
// confirmed in a block.
// Here we only update statistics and not data in CTxMemPool::Parents
// and CTxMemPoolEntry::Children (which we need to preserve until we're
// finished with all operations that need to traverse the mempool).
for (txiter removeIt : entriesToRemove) {
setEntries setDescendants;
CalculateDescendants(removeIt, setDescendants);
setDescendants.erase(removeIt); // don't update state for self
int64_t modifySize = -int64_t(removeIt->GetTxSize());
Amount modifyFee = -1 * removeIt->GetModifiedFee();
int modifySigChecks = -removeIt->GetSigChecks();
for (txiter dit : setDescendants) {
mapTx.modify(dit, update_ancestor_state(modifySize, modifyFee,
-1, modifySigChecks));
}
}
}
for (txiter removeIt : entriesToRemove) {
setEntries setAncestors;
const CTxMemPoolEntry &entry = *removeIt;
std::string dummy;
// Since this is a tx that is already in the mempool, we can call CMPA
// with fSearchForParents = false. If the mempool is in a consistent
// state, then using true or false should both be correct, though false
// should be a bit faster.
// However, if we happen to be in the middle of processing a reorg, then
// the mempool can be in an inconsistent state. In this case, the set
// of ancestors reachable via GetMemPoolParents()/GetMemPoolChildren()
// will be the same as the set of ancestors whose packages include this
// transaction, because when we add a new transaction to the mempool in
// addUnchecked(), we assume it has no children, and in the case of a
// reorg where that assumption is false, the in-mempool children aren't
// linked to the in-block tx's until UpdateTransactionsFromBlock() is
// called.
// So if we're being called during a reorg, ie before
// UpdateTransactionsFromBlock() has been called, then
// GetMemPoolParents()/GetMemPoolChildren() will differ from the set of
// mempool parents we'd calculate by searching, and it's important that
// we use the cached notion of ancestor transactions as the set of
// things to update for removal.
CalculateMemPoolAncestors(entry, setAncestors, nNoLimit, nNoLimit,
nNoLimit, nNoLimit, dummy, false);
// Note that UpdateAncestorsOf severs the child links that point to
// removeIt in the entries for the parents of removeIt.
UpdateAncestorsOf(false, removeIt, setAncestors);
}
// After updating all the ancestor sizes, we can now sever the link between
// each transaction being removed and any mempool children (ie, update
// CTxMemPoolEntry::m_parents for each direct child of a transaction being
// removed).
for (txiter removeIt : entriesToRemove) {
UpdateChildrenForRemoval(removeIt);
}
}
void CTxMemPoolEntry::UpdateDescendantState(int64_t modifySize,
Amount modifyFee,
int64_t modifyCount,
int64_t modifySigChecks) {
nSizeWithDescendants += modifySize;
assert(int64_t(nSizeWithDescendants) > 0);
nModFeesWithDescendants += modifyFee;
nCountWithDescendants += modifyCount;
assert(int64_t(nCountWithDescendants) > 0);
nSigChecksWithDescendants += modifySigChecks;
- assert(int64_t(nSigChecksWithDescendants) >= 0);
+ assert(nSigChecksWithDescendants >= 0);
}
void CTxMemPoolEntry::UpdateAncestorState(int64_t modifySize, Amount modifyFee,
int64_t modifyCount,
int64_t modifySigChecks) {
nSizeWithAncestors += modifySize;
assert(int64_t(nSizeWithAncestors) > 0);
nModFeesWithAncestors += modifyFee;
nCountWithAncestors += modifyCount;
assert(int64_t(nCountWithAncestors) > 0);
nSigChecksWithAncestors += modifySigChecks;
- assert(int(nSigChecksWithAncestors) >= 0);
+ assert(nSigChecksWithAncestors >= 0);
}
CTxMemPool::CTxMemPool(int check_ratio) : m_check_ratio(check_ratio) {
// lock free clear
_clear();
}
CTxMemPool::~CTxMemPool() {}
bool CTxMemPool::isSpent(const COutPoint &outpoint) const {
LOCK(cs);
return mapNextTx.count(outpoint);
}
unsigned int CTxMemPool::GetTransactionsUpdated() const {
return nTransactionsUpdated;
}
void CTxMemPool::AddTransactionsUpdated(unsigned int n) {
nTransactionsUpdated += n;
}
void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry,
setEntries &setAncestors) {
// Add to memory pool without checking anything.
// Used by AcceptToMemoryPool(), which DOES do all the appropriate checks.
indexed_transaction_set::iterator newit = mapTx.insert(entry).first;
// Update transaction for any feeDelta created by PrioritiseTransaction
Amount feeDelta = Amount::zero();
ApplyDelta(entry.GetTx().GetId(), feeDelta);
if (feeDelta != Amount::zero()) {
mapTx.modify(newit, [&feeDelta](CTxMemPoolEntry &e) {
e.UpdateFeeDelta(feeDelta);
});
}
// Update cachedInnerUsage to include contained transaction's usage.
// (When we update the entry for in-mempool parents, memory usage will be
// further updated.)
cachedInnerUsage += entry.DynamicMemoryUsage();
const CTransaction &tx = newit->GetTx();
std::set<TxId> setParentTransactions;
for (const CTxIn &in : tx.vin) {
mapNextTx.insert(std::make_pair(&in.prevout, &tx));
setParentTransactions.insert(in.prevout.GetTxId());
}
// Don't bother worrying about child transactions of this one. Normal case
// of a new transaction arriving is that there can't be any children,
// because such children would be orphans. An exception to that is if a
// transaction enters that used to be in a block. In that case, our
// disconnect block logic will call UpdateTransactionsFromBlock to clean up
// the mess we're leaving here.
// Update ancestors with information about this tx
for (const auto &pit : GetIterSet(setParentTransactions)) {
UpdateParent(newit, pit, true);
}
UpdateAncestorsOf(true, newit, setAncestors);
UpdateEntryForAncestors(newit, setAncestors);
nTransactionsUpdated++;
totalTxSize += entry.GetTxSize();
m_total_fee += entry.GetFee();
vTxHashes.emplace_back(tx.GetHash(), newit);
newit->vTxHashesIdx = vTxHashes.size() - 1;
}
void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason) {
// We increment mempool sequence value no matter removal reason
// even if not directly reported below.
uint64_t mempool_sequence = GetAndIncrementSequence();
if (reason != MemPoolRemovalReason::BLOCK) {
// Notify clients that a transaction has been removed from the mempool
// for any reason except being included in a block. Clients interested
// in transactions included in blocks can subscribe to the
// BlockConnected notification.
GetMainSignals().TransactionRemovedFromMempool(
it->GetSharedTx(), reason, mempool_sequence);
}
for (const CTxIn &txin : it->GetTx().vin) {
mapNextTx.erase(txin.prevout);
}
/* add logging because unchecked */
RemoveUnbroadcastTx(it->GetTx().GetId(), true);
if (vTxHashes.size() > 1) {
vTxHashes[it->vTxHashesIdx] = std::move(vTxHashes.back());
vTxHashes[it->vTxHashesIdx].second->vTxHashesIdx = it->vTxHashesIdx;
vTxHashes.pop_back();
if (vTxHashes.size() * 2 < vTxHashes.capacity()) {
vTxHashes.shrink_to_fit();
}
} else {
vTxHashes.clear();
}
totalTxSize -= it->GetTxSize();
m_total_fee -= it->GetFee();
cachedInnerUsage -= it->DynamicMemoryUsage();
cachedInnerUsage -= memusage::DynamicUsage(it->GetMemPoolParentsConst()) +
memusage::DynamicUsage(it->GetMemPoolChildrenConst());
mapTx.erase(it);
nTransactionsUpdated++;
}
// Calculates descendants of entry that are not already in setDescendants, and
// adds to setDescendants. Assumes entryit is already a tx in the mempool and
// CTxMemPoolEntry::m_children is correct for tx and all descendants. Also
// assumes that if an entry is in setDescendants already, then all in-mempool
// descendants of it are already in setDescendants as well, so that we can save
// time by not iterating over those entries.
void CTxMemPool::CalculateDescendants(txiter entryit,
setEntries &setDescendants) const {
setEntries stage;
if (setDescendants.count(entryit) == 0) {
stage.insert(entryit);
}
// Traverse down the children of entry, only adding children that are not
// accounted for in setDescendants already (because those children have
// either already been walked, or will be walked in this iteration).
while (!stage.empty()) {
txiter it = *stage.begin();
setDescendants.insert(it);
stage.erase(it);
const CTxMemPoolEntry::Children &children =
it->GetMemPoolChildrenConst();
for (const CTxMemPoolEntry &child : children) {
txiter childiter = mapTx.iterator_to(child);
if (!setDescendants.count(childiter)) {
stage.insert(childiter);
}
}
}
}
void CTxMemPool::removeRecursive(const CTransaction &origTx,
MemPoolRemovalReason reason) {
// Remove transaction from memory pool.
AssertLockHeld(cs);
setEntries txToRemove;
txiter origit = mapTx.find(origTx.GetId());
if (origit != mapTx.end()) {
txToRemove.insert(origit);
} else {
// When recursively removing but origTx isn't in the mempool be sure to
// remove any children that are in the pool. This can happen during
// chain re-orgs if origTx isn't re-accepted into the mempool for any
// reason.
for (size_t i = 0; i < origTx.vout.size(); i++) {
auto it = mapNextTx.find(COutPoint(origTx.GetId(), i));
if (it == mapNextTx.end()) {
continue;
}
txiter nextit = mapTx.find(it->second->GetId());
assert(nextit != mapTx.end());
txToRemove.insert(nextit);
}
}
setEntries setAllRemoves;
for (txiter it : txToRemove) {
CalculateDescendants(it, setAllRemoves);
}
RemoveStaged(setAllRemoves, false, reason);
}
void CTxMemPool::removeForReorg(
const Config &config, CChain &chain,
std::function<bool(txiter)> check_final_and_mature) {
// Remove transactions spending a coinbase which are now immature and
// no-longer-final transactions.
AssertLockHeld(cs);
AssertLockHeld(::cs_main);
setEntries txToRemove;
for (indexed_transaction_set::const_iterator it = mapTx.begin();
it != mapTx.end(); it++) {
if (check_final_and_mature(it)) {
txToRemove.insert(it);
}
}
setEntries setAllRemoves;
for (txiter it : txToRemove) {
CalculateDescendants(it, setAllRemoves);
}
RemoveStaged(setAllRemoves, false, MemPoolRemovalReason::REORG);
for (indexed_transaction_set::const_iterator it = mapTx.begin();
it != mapTx.end(); it++) {
assert(TestLockPointValidity(chain, it->GetLockPoints()));
}
}
void CTxMemPool::removeConflicts(const CTransaction &tx) {
// Remove transactions which depend on inputs of tx, recursively
AssertLockHeld(cs);
for (const CTxIn &txin : tx.vin) {
auto it = mapNextTx.find(txin.prevout);
if (it != mapNextTx.end()) {
const CTransaction &txConflict = *it->second;
if (txConflict != tx) {
ClearPrioritisation(txConflict.GetId());
removeRecursive(txConflict, MemPoolRemovalReason::CONFLICT);
}
}
}
}
/**
* Called when a block is connected. Removes from mempool and updates the miner
* fee estimator.
*/
void CTxMemPool::removeForBlock(const std::vector<CTransactionRef> &vtx,
unsigned int nBlockHeight) {
AssertLockHeld(cs);
DisconnectedBlockTransactions disconnectpool;
disconnectpool.addForBlock(vtx, *this);
std::vector<const CTxMemPoolEntry *> entries;
for (const CTransactionRef &tx :
reverse_iterate(disconnectpool.GetQueuedTx().get<insertion_order>())) {
const TxId &txid = tx->GetId();
indexed_transaction_set::iterator i = mapTx.find(txid);
if (i != mapTx.end()) {
entries.push_back(&*i);
}
}
for (const CTransactionRef &tx :
reverse_iterate(disconnectpool.GetQueuedTx().get<insertion_order>())) {
txiter it = mapTx.find(tx->GetId());
if (it != mapTx.end()) {
setEntries stage;
stage.insert(it);
RemoveStaged(stage, true, MemPoolRemovalReason::BLOCK);
}
removeConflicts(*tx);
ClearPrioritisation(tx->GetId());
}
disconnectpool.clear();
lastRollingFeeUpdate = GetTime();
blockSinceLastRollingFeeBump = true;
}
void CTxMemPool::_clear() {
mapTx.clear();
mapNextTx.clear();
vTxHashes.clear();
totalTxSize = 0;
m_total_fee = Amount::zero();
cachedInnerUsage = 0;
lastRollingFeeUpdate = GetTime();
blockSinceLastRollingFeeBump = false;
rollingMinimumFeeRate = 0;
++nTransactionsUpdated;
}
void CTxMemPool::clear() {
LOCK(cs);
_clear();
}
void CTxMemPool::check(const CCoinsViewCache &active_coins_tip,
int64_t spendheight) const {
if (m_check_ratio == 0) {
return;
}
if (GetRand(m_check_ratio) >= 1) {
return;
}
AssertLockHeld(::cs_main);
LOCK(cs);
LogPrint(BCLog::MEMPOOL,
"Checking mempool with %u transactions and %u inputs\n",
(unsigned int)mapTx.size(), (unsigned int)mapNextTx.size());
uint64_t checkTotal = 0;
Amount check_total_fee{Amount::zero()};
uint64_t innerUsage = 0;
uint64_t prev_ancestor_count{0};
CCoinsViewCache mempoolDuplicate(
const_cast<CCoinsViewCache *>(&active_coins_tip));
for (const auto &it : GetSortedDepthAndScore()) {
checkTotal += it->GetTxSize();
check_total_fee += it->GetFee();
innerUsage += it->DynamicMemoryUsage();
const CTransaction &tx = it->GetTx();
innerUsage += memusage::DynamicUsage(it->GetMemPoolParentsConst()) +
memusage::DynamicUsage(it->GetMemPoolChildrenConst());
CTxMemPoolEntry::Parents setParentCheck;
for (const CTxIn &txin : tx.vin) {
// Check that every mempool transaction's inputs refer to available
// coins, or other mempool tx's.
indexed_transaction_set::const_iterator it2 =
mapTx.find(txin.prevout.GetTxId());
if (it2 != mapTx.end()) {
const CTransaction &tx2 = it2->GetTx();
assert(tx2.vout.size() > txin.prevout.GetN() &&
!tx2.vout[txin.prevout.GetN()].IsNull());
setParentCheck.insert(*it2);
}
// We are iterating through the mempool entries sorted in order by
// ancestor count.
// All parents must have been checked before their children and
// their coins added to the mempoolDuplicate coins cache.
assert(mempoolDuplicate.HaveCoin(txin.prevout));
// Check whether its inputs are marked in mapNextTx.
auto it3 = mapNextTx.find(txin.prevout);
assert(it3 != mapNextTx.end());
assert(it3->first == &txin.prevout);
assert(it3->second == &tx);
}
auto comp = [](const CTxMemPoolEntry &a,
const CTxMemPoolEntry &b) -> bool {
return a.GetTx().GetId() == b.GetTx().GetId();
};
assert(setParentCheck.size() == it->GetMemPoolParentsConst().size());
assert(std::equal(setParentCheck.begin(), setParentCheck.end(),
it->GetMemPoolParentsConst().begin(), comp));
// Verify ancestor state is correct.
setEntries setAncestors;
uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
std::string dummy;
CalculateMemPoolAncestors(*it, setAncestors, nNoLimit, nNoLimit,
nNoLimit, nNoLimit, dummy);
uint64_t nCountCheck = setAncestors.size() + 1;
uint64_t nSizeCheck = it->GetTxSize();
Amount nFeesCheck = it->GetModifiedFee();
int64_t nSigChecksCheck = it->GetSigChecks();
for (txiter ancestorIt : setAncestors) {
nSizeCheck += ancestorIt->GetTxSize();
nFeesCheck += ancestorIt->GetModifiedFee();
nSigChecksCheck += ancestorIt->GetSigChecks();
}
assert(it->GetCountWithAncestors() == nCountCheck);
assert(it->GetSizeWithAncestors() == nSizeCheck);
assert(it->GetSigChecksWithAncestors() == nSigChecksCheck);
assert(it->GetModFeesWithAncestors() == nFeesCheck);
// Sanity check: we are walking in ascending ancestor count order.
assert(prev_ancestor_count <= it->GetCountWithAncestors());
prev_ancestor_count = it->GetCountWithAncestors();
// Check children against mapNextTx
CTxMemPoolEntry::Children setChildrenCheck;
auto iter = mapNextTx.lower_bound(COutPoint(it->GetTx().GetId(), 0));
uint64_t child_sizes = 0;
int64_t child_sigChecks = 0;
for (; iter != mapNextTx.end() &&
iter->first->GetTxId() == it->GetTx().GetId();
++iter) {
txiter childit = mapTx.find(iter->second->GetId());
// mapNextTx points to in-mempool transactions
assert(childit != mapTx.end());
if (setChildrenCheck.insert(*childit).second) {
child_sizes += childit->GetTxSize();
child_sigChecks += childit->GetSigChecks();
}
}
assert(setChildrenCheck.size() == it->GetMemPoolChildrenConst().size());
assert(std::equal(setChildrenCheck.begin(), setChildrenCheck.end(),
it->GetMemPoolChildrenConst().begin(), comp));
// Also check to make sure size is greater than sum with immediate
// children. Just a sanity check, not definitive that this calc is
// correct...
assert(it->GetSizeWithDescendants() >= child_sizes + it->GetTxSize());
assert(it->GetSigChecksWithDescendants() >=
child_sigChecks + it->GetSigChecks());
// Not used. CheckTxInputs() should always pass
TxValidationState dummy_state;
Amount txfee{Amount::zero()};
assert(!tx.IsCoinBase());
assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate,
spendheight, txfee));
for (const auto &input : tx.vin) {
mempoolDuplicate.SpendCoin(input.prevout);
}
AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
}
for (auto it = mapNextTx.cbegin(); it != mapNextTx.cend(); it++) {
const TxId &txid = it->second->GetId();
indexed_transaction_set::const_iterator it2 = mapTx.find(txid);
const CTransaction &tx = it2->GetTx();
assert(it2 != mapTx.end());
assert(&tx == it->second);
}
assert(totalTxSize == checkTotal);
assert(m_total_fee == check_total_fee);
assert(innerUsage == cachedInnerUsage);
}
bool CTxMemPool::CompareDepthAndScore(const TxId &txida, const TxId &txidb) {
LOCK(cs);
indexed_transaction_set::const_iterator i = mapTx.find(txida);
if (i == mapTx.end()) {
return false;
}
indexed_transaction_set::const_iterator j = mapTx.find(txidb);
if (j == mapTx.end()) {
return true;
}
uint64_t counta = i->GetCountWithAncestors();
uint64_t countb = j->GetCountWithAncestors();
if (counta == countb) {
return CompareTxMemPoolEntryByScore()(*i, *j);
}
return counta < countb;
}
namespace {
class DepthAndScoreComparator {
public:
bool
operator()(const CTxMemPool::indexed_transaction_set::const_iterator &a,
const CTxMemPool::indexed_transaction_set::const_iterator &b) {
uint64_t counta = a->GetCountWithAncestors();
uint64_t countb = b->GetCountWithAncestors();
if (counta == countb) {
return CompareTxMemPoolEntryByScore()(*a, *b);
}
return counta < countb;
}
};
} // namespace
std::vector<CTxMemPool::indexed_transaction_set::const_iterator>
CTxMemPool::GetSortedDepthAndScore() const {
std::vector<indexed_transaction_set::const_iterator> iters;
AssertLockHeld(cs);
iters.reserve(mapTx.size());
for (indexed_transaction_set::iterator mi = mapTx.begin();
mi != mapTx.end(); ++mi) {
iters.push_back(mi);
}
std::sort(iters.begin(), iters.end(), DepthAndScoreComparator());
return iters;
}
void CTxMemPool::queryHashes(std::vector<uint256> &vtxid) const {
LOCK(cs);
auto iters = GetSortedDepthAndScore();
vtxid.clear();
vtxid.reserve(mapTx.size());
for (auto it : iters) {
vtxid.push_back(it->GetTx().GetId());
}
}
static TxMempoolInfo
GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it) {
return TxMempoolInfo{it->GetSharedTx(), it->GetTime(), it->GetFee(),
it->GetTxSize(), it->GetModifiedFee() - it->GetFee()};
}
std::vector<TxMempoolInfo> CTxMemPool::infoAll() const {
LOCK(cs);
auto iters = GetSortedDepthAndScore();
std::vector<TxMempoolInfo> ret;
ret.reserve(mapTx.size());
for (auto it : iters) {
ret.push_back(GetInfo(it));
}
return ret;
}
CTransactionRef CTxMemPool::get(const TxId &txid) const {
LOCK(cs);
indexed_transaction_set::const_iterator i = mapTx.find(txid);
if (i == mapTx.end()) {
return nullptr;
}
return i->GetSharedTx();
}
TxMempoolInfo CTxMemPool::info(const TxId &txid) const {
LOCK(cs);
indexed_transaction_set::const_iterator i = mapTx.find(txid);
if (i == mapTx.end()) {
return TxMempoolInfo();
}
return GetInfo(i);
}
CFeeRate CTxMemPool::estimateFee() const {
LOCK(cs);
uint64_t maxMempoolSize =
gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
// minerPolicy uses recent blocks to figure out a reasonable fee. This
// may disagree with the rollingMinimumFeerate under certain scenarios
// where the mempool increases rapidly, or blocks are being mined which
// do not contain propagated transactions.
return std::max(::minRelayTxFee, GetMinFee(maxMempoolSize));
}
void CTxMemPool::PrioritiseTransaction(const TxId &txid,
const Amount nFeeDelta) {
{
LOCK(cs);
Amount &delta = mapDeltas[txid];
delta += nFeeDelta;
txiter it = mapTx.find(txid);
if (it != mapTx.end()) {
mapTx.modify(
it, [&delta](CTxMemPoolEntry &e) { e.UpdateFeeDelta(delta); });
// Now update all ancestors' modified fees with descendants
setEntries setAncestors;
uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
std::string dummy;
CalculateMemPoolAncestors(*it, setAncestors, nNoLimit, nNoLimit,
nNoLimit, nNoLimit, dummy, false);
for (txiter ancestorIt : setAncestors) {
mapTx.modify(ancestorIt,
update_descendant_state(0, nFeeDelta, 0, 0));
}
// Now update all descendants' modified fees with ancestors
setEntries setDescendants;
CalculateDescendants(it, setDescendants);
setDescendants.erase(it);
for (txiter descendantIt : setDescendants) {
mapTx.modify(descendantIt,
update_ancestor_state(0, nFeeDelta, 0, 0));
}
++nTransactionsUpdated;
}
}
LogPrintf("PrioritiseTransaction: %s fee += %s\n", txid.ToString(),
FormatMoney(nFeeDelta));
}
void CTxMemPool::ApplyDelta(const TxId &txid, Amount &nFeeDelta) const {
AssertLockHeld(cs);
std::map<TxId, Amount>::const_iterator pos = mapDeltas.find(txid);
if (pos == mapDeltas.end()) {
return;
}
nFeeDelta += pos->second;
}
void CTxMemPool::ClearPrioritisation(const TxId &txid) {
AssertLockHeld(cs);
mapDeltas.erase(txid);
}
const CTransaction *CTxMemPool::GetConflictTx(const COutPoint &prevout) const {
const auto it = mapNextTx.find(prevout);
return it == mapNextTx.end() ? nullptr : it->second;
}
std::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const TxId &txid) const {
auto it = mapTx.find(txid);
if (it != mapTx.end()) {
return it;
}
return std::nullopt;
}
CTxMemPool::setEntries
CTxMemPool::GetIterSet(const std::set<TxId> &txids) const {
CTxMemPool::setEntries ret;
for (const auto &txid : txids) {
const auto mi = GetIter(txid);
if (mi) {
ret.insert(*mi);
}
}
return ret;
}
bool CTxMemPool::HasNoInputsOf(const CTransaction &tx) const {
for (const CTxIn &in : tx.vin) {
if (exists(in.prevout.GetTxId())) {
return false;
}
}
return true;
}
CCoinsViewMemPool::CCoinsViewMemPool(CCoinsView *baseIn,
const CTxMemPool &mempoolIn)
: CCoinsViewBacked(baseIn), mempool(mempoolIn) {}
bool CCoinsViewMemPool::GetCoin(const COutPoint &outpoint, Coin &coin) const {
// Check to see if the inputs are made available by another tx in the
// package. These Coins would not be available in the underlying CoinsView.
if (auto it = m_temp_added.find(outpoint); it != m_temp_added.end()) {
coin = it->second;
return true;
}
// If an entry in the mempool exists, always return that one, as it's
// guaranteed to never conflict with the underlying cache, and it cannot
// have pruned entries (as it contains full) transactions. First checking
// the underlying cache risks returning a pruned entry instead.
CTransactionRef ptx = mempool.get(outpoint.GetTxId());
if (ptx) {
if (outpoint.GetN() < ptx->vout.size()) {
coin = Coin(ptx->vout[outpoint.GetN()], MEMPOOL_HEIGHT, false);
return true;
}
return false;
}
return base->GetCoin(outpoint, coin);
}
void CCoinsViewMemPool::PackageAddTransaction(const CTransactionRef &tx) {
for (uint32_t n = 0; n < tx->vout.size(); ++n) {
m_temp_added.emplace(COutPoint(tx->GetId(), n),
Coin(tx->vout[n], MEMPOOL_HEIGHT, false));
}
}
size_t CTxMemPool::DynamicMemoryUsage() const {
LOCK(cs);
// Estimate the overhead of mapTx to be 12 pointers + an allocation, as no
// exact formula for boost::multi_index_contained is implemented.
return memusage::MallocUsage(sizeof(CTxMemPoolEntry) +
12 * sizeof(void *)) *
mapTx.size() +
memusage::DynamicUsage(mapNextTx) +
memusage::DynamicUsage(mapDeltas) +
memusage::DynamicUsage(vTxHashes) + cachedInnerUsage;
}
void CTxMemPool::RemoveUnbroadcastTx(const TxId &txid, const bool unchecked) {
LOCK(cs);
if (m_unbroadcast_txids.erase(txid)) {
LogPrint(
BCLog::MEMPOOL, "Removed %i from set of unbroadcast txns%s\n",
txid.GetHex(),
(unchecked ? " before confirmation that txn was sent out" : ""));
}
}
void CTxMemPool::RemoveStaged(setEntries &stage, bool updateDescendants,
MemPoolRemovalReason reason) {
AssertLockHeld(cs);
UpdateForRemoveFromMempool(stage, updateDescendants);
for (txiter it : stage) {
removeUnchecked(it, reason);
}
}
int CTxMemPool::Expire(std::chrono::seconds time) {
AssertLockHeld(cs);
indexed_transaction_set::index<entry_time>::type::iterator it =
mapTx.get<entry_time>().begin();
setEntries toremove;
while (it != mapTx.get<entry_time>().end() && it->GetTime() < time) {
toremove.insert(mapTx.project<0>(it));
it++;
}
setEntries stage;
for (txiter removeit : toremove) {
CalculateDescendants(removeit, stage);
}
RemoveStaged(stage, false, MemPoolRemovalReason::EXPIRY);
return stage.size();
}
void CTxMemPool::LimitSize(CCoinsViewCache &coins_cache, size_t limit,
std::chrono::seconds age) {
int expired = Expire(GetTime<std::chrono::seconds>() - age);
if (expired != 0) {
LogPrint(BCLog::MEMPOOL,
"Expired %i transactions from the memory pool\n", expired);
}
std::vector<COutPoint> vNoSpendsRemaining;
TrimToSize(limit, &vNoSpendsRemaining);
for (const COutPoint &removed : vNoSpendsRemaining) {
coins_cache.Uncache(removed);
}
}
void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry) {
setEntries setAncestors;
uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
std::string dummy;
CalculateMemPoolAncestors(entry, setAncestors, nNoLimit, nNoLimit, nNoLimit,
nNoLimit, dummy);
return addUnchecked(entry, setAncestors);
}
void CTxMemPool::UpdateChild(txiter entry, txiter child, bool add) {
AssertLockHeld(cs);
CTxMemPoolEntry::Children s;
if (add && entry->GetMemPoolChildren().insert(*child).second) {
cachedInnerUsage += memusage::IncrementalDynamicUsage(s);
} else if (!add && entry->GetMemPoolChildren().erase(*child)) {
cachedInnerUsage -= memusage::IncrementalDynamicUsage(s);
}
}
void CTxMemPool::UpdateParent(txiter entry, txiter parent, bool add) {
AssertLockHeld(cs);
CTxMemPoolEntry::Parents s;
if (add && entry->GetMemPoolParents().insert(*parent).second) {
cachedInnerUsage += memusage::IncrementalDynamicUsage(s);
} else if (!add && entry->GetMemPoolParents().erase(*parent)) {
cachedInnerUsage -= memusage::IncrementalDynamicUsage(s);
}
}
CFeeRate CTxMemPool::GetMinFee(size_t sizelimit) const {
LOCK(cs);
if (!blockSinceLastRollingFeeBump || rollingMinimumFeeRate == 0) {
return CFeeRate(int64_t(ceill(rollingMinimumFeeRate)) * SATOSHI);
}
int64_t time = GetTime();
if (time > lastRollingFeeUpdate + 10) {
double halflife = ROLLING_FEE_HALFLIFE;
if (DynamicMemoryUsage() < sizelimit / 4) {
halflife /= 4;
} else if (DynamicMemoryUsage() < sizelimit / 2) {
halflife /= 2;
}
rollingMinimumFeeRate =
rollingMinimumFeeRate /
pow(2.0, (time - lastRollingFeeUpdate) / halflife);
lastRollingFeeUpdate = time;
}
return CFeeRate(int64_t(ceill(rollingMinimumFeeRate)) * SATOSHI);
}
void CTxMemPool::trackPackageRemoved(const CFeeRate &rate) {
AssertLockHeld(cs);
if ((rate.GetFeePerK() / SATOSHI) > rollingMinimumFeeRate) {
rollingMinimumFeeRate = rate.GetFeePerK() / SATOSHI;
blockSinceLastRollingFeeBump = false;
}
}
void CTxMemPool::TrimToSize(size_t sizelimit,
std::vector<COutPoint> *pvNoSpendsRemaining) {
AssertLockHeld(cs);
unsigned nTxnRemoved = 0;
CFeeRate maxFeeRateRemoved(Amount::zero());
while (!mapTx.empty() && DynamicMemoryUsage() > sizelimit) {
indexed_transaction_set::index<descendant_score>::type::iterator it =
mapTx.get<descendant_score>().begin();
// We set the new mempool min fee to the feerate of the removed set,
// plus the "minimum reasonable fee rate" (ie some value under which we
// consider txn to have 0 fee). This way, we don't allow txn to enter
// mempool with feerate equal to txn which were removed with no block in
// between.
CFeeRate removed(it->GetModFeesWithDescendants(),
it->GetVirtualSizeWithDescendants());
removed += MEMPOOL_FULL_FEE_INCREMENT;
trackPackageRemoved(removed);
maxFeeRateRemoved = std::max(maxFeeRateRemoved, removed);
setEntries stage;
CalculateDescendants(mapTx.project<0>(it), stage);
nTxnRemoved += stage.size();
std::vector<CTransaction> txn;
if (pvNoSpendsRemaining) {
txn.reserve(stage.size());
for (txiter iter : stage) {
txn.push_back(iter->GetTx());
}
}
RemoveStaged(stage, false, MemPoolRemovalReason::SIZELIMIT);
if (pvNoSpendsRemaining) {
for (const CTransaction &tx : txn) {
for (const CTxIn &txin : tx.vin) {
if (exists(txin.prevout.GetTxId())) {
continue;
}
pvNoSpendsRemaining->push_back(txin.prevout);
}
}
}
}
if (maxFeeRateRemoved > CFeeRate(Amount::zero())) {
LogPrint(BCLog::MEMPOOL,
"Removed %u txn, rolling minimum fee bumped to %s\n",
nTxnRemoved, maxFeeRateRemoved.ToString());
}
}
uint64_t CTxMemPool::CalculateDescendantMaximum(txiter entry) const {
// find parent with highest descendant count
std::vector<txiter> candidates;
setEntries counted;
candidates.push_back(entry);
uint64_t maximum = 0;
while (candidates.size()) {
txiter candidate = candidates.back();
candidates.pop_back();
if (!counted.insert(candidate).second) {
continue;
}
const CTxMemPoolEntry::Parents &parents =
candidate->GetMemPoolParentsConst();
if (parents.size() == 0) {
maximum = std::max(maximum, candidate->GetCountWithDescendants());
} else {
for (const CTxMemPoolEntry &i : parents) {
candidates.push_back(mapTx.iterator_to(i));
}
}
}
return maximum;
}
void CTxMemPool::GetTransactionAncestry(const TxId &txid, size_t &ancestors,
size_t &descendants,
size_t *const ancestorsize,
Amount *const ancestorfees) const {
LOCK(cs);
auto it = mapTx.find(txid);
ancestors = descendants = 0;
if (it != mapTx.end()) {
ancestors = it->GetCountWithAncestors();
if (ancestorsize) {
*ancestorsize = it->GetSizeWithAncestors();
}
if (ancestorfees) {
*ancestorfees = it->GetModFeesWithAncestors();
}
descendants = CalculateDescendantMaximum(it);
}
}
bool CTxMemPool::IsLoaded() const {
LOCK(cs);
return m_is_loaded;
}
void CTxMemPool::SetIsLoaded(bool loaded) {
LOCK(cs);
m_is_loaded = loaded;
}
/** Maximum bytes for transactions to store for processing during reorg */
static const size_t MAX_DISCONNECTED_TX_POOL_SIZE = 20 * DEFAULT_MAX_BLOCK_SIZE;
void DisconnectedBlockTransactions::addForBlock(
const std::vector<CTransactionRef> &vtx, CTxMemPool &pool) {
AssertLockHeld(pool.cs);
for (const auto &tx : reverse_iterate(vtx)) {
// If we already added it, just skip.
auto it = queuedTx.find(tx->GetId());
if (it != queuedTx.end()) {
continue;
}
// Insert the transaction into the pool.
addTransaction(tx);
// Fill in the set of parents.
std::unordered_set<TxId, SaltedTxIdHasher> parents;
for (const CTxIn &in : tx->vin) {
parents.insert(in.prevout.GetTxId());
}
// In order to make sure we keep things in topological order, we check
// if we already know of the parent of the current transaction. If so,
// we remove them from the set and then add them back.
while (parents.size() > 0) {
std::unordered_set<TxId, SaltedTxIdHasher> worklist(
std::move(parents));
parents.clear();
for (const TxId &txid : worklist) {
// If we do not have that txid in the set, nothing needs to be
// done.
auto pit = queuedTx.find(txid);
if (pit == queuedTx.end()) {
continue;
}
// We have parent in our set, we reinsert them at the right
// position.
const CTransactionRef ptx = *pit;
queuedTx.erase(pit);
queuedTx.insert(ptx);
// And we make sure ancestors are covered.
for (const CTxIn &in : ptx->vin) {
parents.insert(in.prevout.GetTxId());
}
}
}
}
// Keep the size under control.
while (DynamicMemoryUsage() > MAX_DISCONNECTED_TX_POOL_SIZE) {
// Drop the earliest entry, and remove its children from the
// mempool.
auto it = queuedTx.get<insertion_order>().begin();
pool.removeRecursive(**it, MemPoolRemovalReason::REORG);
removeEntry(it);
}
}
void DisconnectedBlockTransactions::importMempool(CTxMemPool &pool) {
AssertLockHeld(pool.cs);
// addForBlock's algorithm sorts a vector of transactions back into
// topological order. We use it in a separate object to create a valid
// ordering of all mempool transactions, which we then splice in front of
// the current queuedTx. This results in a valid sequence of transactions to
// be reprocessed in updateMempoolForReorg.
// We create vtx in order of the entry_time index to facilitate for
// addForBlocks (which iterates in reverse order), as vtx probably end in
// the correct ordering for queuedTx.
std::vector<CTransactionRef> vtx;
vtx.reserve(pool.mapTx.size());
for (const CTxMemPoolEntry &e : pool.mapTx.get<entry_time>()) {
vtx.push_back(e.GetSharedTx());
}
pool.clear();
// Use addForBlocks to sort the transactions and then splice them in front
// of queuedTx
DisconnectedBlockTransactions orderedTxnPool;
orderedTxnPool.addForBlock(vtx, pool);
cachedInnerUsage += orderedTxnPool.cachedInnerUsage;
queuedTx.get<insertion_order>().splice(
queuedTx.get<insertion_order>().begin(),
orderedTxnPool.queuedTx.get<insertion_order>());
// We limit memory usage because we can't know if more blocks will be
// disconnected
while (DynamicMemoryUsage() > MAX_DISCONNECTED_TX_POOL_SIZE) {
// Drop the earliest entry which, by definition, has no children
removeEntry(queuedTx.get<insertion_order>().begin());
}
}
void DisconnectedBlockTransactions::updateMempoolForReorg(
const Config &config, CChainState &active_chainstate, bool fAddToMempool,
CTxMemPool &pool) {
AssertLockHeld(cs_main);
AssertLockHeld(pool.cs);
std::vector<TxId> txidsUpdate;
// disconnectpool's insertion_order index sorts the entries from oldest to
// newest, but the oldest entry will be the last tx from the latest mined
// block that was disconnected.
// Iterate disconnectpool in reverse, so that we add transactions back to
// the mempool starting with the earliest transaction that had been
// previously seen in a block.
for (const CTransactionRef &tx :
reverse_iterate(queuedTx.get<insertion_order>())) {
// ignore validation errors in resurrected transactions
if (!fAddToMempool || tx->IsCoinBase() ||
AcceptToMemoryPool(config, active_chainstate, tx, GetTime(),
/*bypass_limits=*/true,
/*test_accept=*/false)
.m_result_type != MempoolAcceptResult::ResultType::VALID) {
// If the transaction doesn't make it in to the mempool, remove any
// transactions that depend on it (which would now be orphans).
pool.removeRecursive(*tx, MemPoolRemovalReason::REORG);
} else if (pool.exists(tx->GetId())) {
txidsUpdate.push_back(tx->GetId());
}
}
queuedTx.clear();
// AcceptToMemoryPool/addUnchecked all assume that new mempool entries have
// no in-mempool children, which is generally not true when adding
// previously-confirmed transactions back to the mempool.
// UpdateTransactionsFromBlock finds descendants of any transactions in the
// disconnectpool that were added back and cleans up the mempool state.
const uint64_t ancestor_count_limit =
gArgs.GetIntArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
const uint64_t ancestor_size_limit =
gArgs.GetIntArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT) *
1000;
pool.UpdateTransactionsFromBlock(txidsUpdate, ancestor_size_limit,
ancestor_count_limit);
// Predicate to use for filtering transactions in removeForReorg.
// Checks whether the transaction is still final and, if it spends a
// coinbase output, mature.
// Also updates valid entries' cached LockPoints if needed.
// If false, the tx is still valid and its lockpoints are updated.
// If true, the tx would be invalid in the next block; remove this entry
// and all of its descendants.
const auto filter_final_and_mature =
[&pool, &active_chainstate, flags = STANDARD_LOCKTIME_VERIFY_FLAGS,
&config](CTxMemPool::txiter it) EXCLUSIVE_LOCKS_REQUIRED(pool.cs,
::cs_main) {
AssertLockHeld(pool.cs);
AssertLockHeld(::cs_main);
const CTransaction &tx = it->GetTx();
// The transaction must be final.
TxValidationState state;
if (!ContextualCheckTransactionForCurrentBlock(
active_chainstate.m_chain.Tip(),
config.GetChainParams().GetConsensus(), tx, state, flags)) {
return true;
}
LockPoints lp = it->GetLockPoints();
const bool validLP{
TestLockPointValidity(active_chainstate.m_chain, lp)};
CCoinsViewMemPool view_mempool(&active_chainstate.CoinsTip(), pool);
// CheckSequenceLocks checks if the transaction will be final in
// the next block to be created on top of the new chain. We use
// useExistingLockPoints=false so that, instead of using the
// information in lp (which might now refer to a block that no
// longer exists in the chain), it will update lp to contain
// LockPoints relevant to the new chain.
if (!CheckSequenceLocks(active_chainstate.m_chain.Tip(),
view_mempool, tx, flags, &lp, validLP)) {
// If CheckSequenceLocks fails, remove the tx and don't depend
// on the LockPoints.
return true;
}
if (!validLP) {
// If CheckSequenceLocks succeeded, it also updated the
// LockPoints. Now update the mempool entry lockpoints as well.
pool.mapTx.modify(
it, [&lp](CTxMemPoolEntry &e) { e.UpdateLockPoints(lp); });
}
// If the transaction spends any coinbase outputs, it must be
// mature.
if (it->GetSpendsCoinbase()) {
for (const CTxIn &txin : tx.vin) {
auto it2 = pool.mapTx.find(txin.prevout.GetTxId());
if (it2 != pool.mapTx.end()) {
continue;
}
const Coin &coin{
active_chainstate.CoinsTip().AccessCoin(txin.prevout)};
assert(!coin.IsSpent());
const auto mempool_spend_height{
active_chainstate.m_chain.Tip()->nHeight + 1};
if (coin.IsCoinBase() &&
mempool_spend_height - coin.GetHeight() <
COINBASE_MATURITY) {
return true;
}
}
}
// Transaction is still valid and cached LockPoints are updated.
return false;
};
// We also need to remove any now-immature transactions
pool.removeForReorg(config, active_chainstate.m_chain,
filter_final_and_mature);
// Re-limit mempool size, in case we added any transactions
pool.LimitSize(active_chainstate.CoinsTip(),
gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *
1000000,
std::chrono::hours{gArgs.GetIntArg("-mempoolexpiry",
DEFAULT_MEMPOOL_EXPIRY)});
}
diff --git a/src/txmempool.h b/src/txmempool.h
index 2bf88305d..7aa024e2e 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -1,1112 +1,1112 @@
// 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 <coins.h>
#include <consensus/amount.h>
#include <core_memusage.h>
#include <indirectmap.h>
#include <policy/packages.h>
#include <primitives/transaction.h>
#include <sync.h>
#include <util/epochguard.h>
#include <util/hasher.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 <atomic>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>
class CBlockIndex;
class CChain;
class CChainState;
class Config;
extern RecursiveMutex cs_main;
/**
* 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{0};
int64_t time{0};
// 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{nullptr};
};
/**
* Test whether the LockPoints height and time are still valid on the current
* chain.
*/
bool TestLockPointValidity(const CChain &active_chain, const LockPoints &lp)
EXCLUSIVE_LOCKS_REQUIRED(cs_main);
struct CompareIteratorById {
// SFINAE for T where T is either a pointer type (e.g., a txiter) or a
// reference_wrapper<T> (e.g. a wrapped CTxMemPoolEntry&)
template <typename T>
bool operator()(const std::reference_wrapper<T> &a,
const std::reference_wrapper<T> &b) const {
return a.get().GetTx().GetId() < b.get().GetTx().GetId();
}
template <typename T> bool operator()(const T &a, const T &b) const {
return a->GetTx().GetId() < b->GetTx().GetId();
}
};
/** \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 {
public:
typedef std::reference_wrapper<const CTxMemPoolEntry> CTxMemPoolEntryRef;
// two aliases, should the types ever diverge
typedef std::set<CTxMemPoolEntryRef, CompareIteratorById> Parents;
typedef std::set<CTxMemPoolEntryRef, CompareIteratorById> Children;
private:
const CTransactionRef tx;
mutable Parents m_parents;
mutable Children m_children;
//! Cached to avoid expensive parent-transaction lookups
const Amount nFee;
//! ... and avoid recomputing tx size
const size_t nTxSize;
//! ... and total memory usage
const size_t nUsageSize;
//! Local time when entering the mempool
const int64_t nTime;
//! Chain height when entering the mempool
const unsigned int entryHeight;
//! keep track of transactions that spend a coinbase
const bool spendsCoinbase;
//! Total sigChecks
const int64_t sigChecks;
//! Used for determining the priority of the transaction for mining in a
//! block
Amount feeDelta{Amount::zero()};
//! 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{1};
//! ... and size
uint64_t nSizeWithDescendants;
//! ... and total fees (all including us)
Amount nModFeesWithDescendants;
//! ... and sichecks
int64_t nSigChecksWithDescendants;
// Analogous statistics for ancestor transactions
uint64_t nCountWithAncestors{1};
uint64_t nSizeWithAncestors;
Amount nModFeesWithAncestors;
int64_t nSigChecksWithAncestors;
public:
CTxMemPoolEntry(const CTransactionRef &_tx, const Amount fee, int64_t time,
unsigned int entry_height, bool spends_coinbase,
int64_t sigchecks, LockPoints lp);
const CTransaction &GetTx() const { return *this->tx; }
CTransactionRef GetSharedTx() const { return this->tx; }
const Amount GetFee() const { return nFee; }
size_t GetTxSize() const { return nTxSize; }
size_t GetTxVirtualSize() const;
std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
unsigned int GetHeight() const { return entryHeight; }
int64_t GetSigChecks() const { return sigChecks; }
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, int64_t modifySigChecks);
// Adjusts the ancestor state
void UpdateAncestorState(int64_t modifySize, Amount modifyFee,
int64_t modifyCount, int64_t modifySigChecks);
// 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; }
uint64_t GetVirtualSizeWithDescendants() const;
Amount GetModFeesWithDescendants() const { return nModFeesWithDescendants; }
int64_t GetSigChecksWithDescendants() const {
return nSigChecksWithDescendants;
}
bool GetSpendsCoinbase() const { return spendsCoinbase; }
uint64_t GetCountWithAncestors() const { return nCountWithAncestors; }
uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
uint64_t GetVirtualSizeWithAncestors() const;
Amount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
int64_t GetSigChecksWithAncestors() const {
return nSigChecksWithAncestors;
}
const Parents &GetMemPoolParentsConst() const { return m_parents; }
const Children &GetMemPoolChildrenConst() const { return m_children; }
Parents &GetMemPoolParents() const { return m_parents; }
Children &GetMemPoolChildren() const { return m_children; }
//! Index in mempool's vTxHashes
mutable size_t vTxHashesIdx;
//! epoch when last touched, useful for graph algorithms
mutable Epoch::Marker m_epoch_marker;
};
// extracts a transaction id from CTxMemPoolEntry or CTransactionRef
struct mempoolentry_txid {
typedef TxId 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 {
double a_mod_fee, a_size, b_mod_fee, b_size;
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 = a_mod_fee * b_size;
double f2 = a_size * b_mod_fee;
if (f1 == f2) {
return a.GetTime() >= b.GetTime();
}
return f1 < f2;
}
// 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.GetVirtualSizeWithDescendants() * (a.GetModifiedFee() / SATOSHI);
double f2 =
a.GetTxVirtualSize() * (a.GetModFeesWithDescendants() / SATOSHI);
if (f2 > f1) {
mod_fee = a.GetModFeesWithDescendants() / SATOSHI;
size = a.GetVirtualSizeWithDescendants();
} else {
mod_fee = a.GetModifiedFee() / SATOSHI;
size = a.GetTxVirtualSize();
}
}
};
/** \class CompareTxMemPoolEntryByScore
*
* Sort by feerate of entry (fee/size) in descending order
* This is only used for transaction relay, so we use GetFee()
* instead of GetModifiedFee() to avoid leaking prioritization
* information via the sort order.
*/
class CompareTxMemPoolEntryByScore {
public:
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
double f1 = b.GetTxSize() * (a.GetFee() / SATOSHI);
double f2 = a.GetTxSize() * (b.GetFee() / 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:
template <typename T> bool operator()(const T &a, const T &b) const {
double a_mod_fee, a_size, b_mod_fee, b_size;
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 = 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.GetVirtualSizeWithAncestors() * (a.GetModifiedFee() / SATOSHI);
double f2 =
a.GetTxVirtualSize() * (a.GetModFeesWithAncestors() / SATOSHI);
if (f1 > f2) {
mod_fee = a.GetModFeesWithAncestors() / SATOSHI;
size = a.GetVirtualSizeWithAncestors();
} else {
mod_fee = a.GetModifiedFee() / SATOSHI;
size = a.GetTxVirtualSize();
}
}
};
// 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. */
std::chrono::seconds m_time;
/** Fee of the transaction. */
Amount fee;
/** Virtual size of the transaction. */
size_t vsize;
/** The fee delta. */
Amount nFeeDelta;
};
/**
* Reason why a transaction was removed from the mempool, this is passed to the
* notification signal.
*/
enum class MemPoolRemovalReason {
//! 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
};
/**
* 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.
+ * the pool.
* - a non-standard transaction.
*
* CTxMemPool::mapTx, and CTxMemPoolEntry bookkeeping:
*
* mapTx is a boost::multi_index that sorts the mempool on 4 criteria:
* - transaction hash
* - descendant feerate [we use max(feerate of tx, feerate of tx with all
* descendants)]
* - time in mempool
* - ancestor feerate [we use min(feerate of tx, feerate of tx with all
* unconfirmed ancestors)]
*
* 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.
+ * set of in-mempool direct parents and direct children in m_parents and
+ * m_children. 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
+ * m_parents and m_children 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 1 times in n we check.
const int m_check_ratio;
//! Used by getblocktemplate to trigger CreateNewBlock() invocation
std::atomic<uint32_t> nTransactionsUpdated{0};
//! sum of all mempool tx's sizes.
uint64_t totalTxSize GUARDED_BY(cs);
//! sum of all mempool tx's fees (NOT modified fee)
Amount m_total_fee GUARDED_BY(cs);
//! sum of dynamic memory usage of all the map elements (NOT the maps
//! themselves)
uint64_t cachedInnerUsage GUARDED_BY(cs);
mutable int64_t lastRollingFeeUpdate GUARDED_BY(cs);
mutable bool blockSinceLastRollingFeeBump GUARDED_BY(cs);
//! minimum fee to get into the pool, decreases exponentially
mutable double rollingMinimumFeeRate GUARDED_BY(cs);
mutable Epoch m_epoch GUARDED_BY(cs);
// In-memory counter for external mempool tracking purposes.
// This number is incremented once every time a transaction
// is added or removed from the mempool for any reason.
mutable uint64_t m_sequence_number GUARDED_BY(cs){1};
void trackPackageRemoved(const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs);
bool m_is_loaded GUARDED_BY(cs){false};
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
+ // indexed 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;
/**
* This mutex needs to be locked when accessing `mapTx` or other members
* that are guarded by it.
*
* @par Consistency guarantees
*
* By design, it is guaranteed that:
*
* 1. Locking both `cs_main` and `mempool.cs` will give a view of mempool
* that is consistent with current chain tip (`ActiveChain()` and
* `CoinsTip()`) and is fully populated. Fully populated means that if
* the current active chain is missing transactions that were present in
* a previously active chain, all the missing transactions will have been
* re-added to the mempool and should be present if they meet size and
* consistency constraints.
*
* 2. Locking `mempool.cs` without `cs_main` will give a view of a mempool
* consistent with some chain that was active since `cs_main` was last
* locked, and that is fully populated as described above. It is ok for
* code that only needs to query or remove transactions from the mempool
* to lock just `mempool.cs` without `cs_main`.
*
* To provide these guarantees, it is necessary to lock both `cs_main` and
* `mempool.cs` whenever adding transactions to the mempool and whenever
* changing the chain tip. It's necessary to keep both mutexes locked until
* the mempool is consistent with the new chain tip and fully populated.
*/
mutable RecursiveMutex cs;
indexed_transaction_set mapTx GUARDED_BY(cs);
using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
//! All tx hashes/entries in mapTx, in random order
std::vector<std::pair<TxHash, txiter>> vTxHashes GUARDED_BY(cs);
typedef std::set<txiter, CompareIteratorById> setEntries;
uint64_t CalculateDescendantMaximum(txiter entry) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
private:
typedef std::map<txiter, setEntries, CompareIteratorById> cacheMap;
void UpdateParent(txiter entry, txiter parent, bool add)
EXCLUSIVE_LOCKS_REQUIRED(cs);
void UpdateChild(txiter entry, txiter child, bool add)
EXCLUSIVE_LOCKS_REQUIRED(cs);
std::vector<indexed_transaction_set::const_iterator>
GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* Track locally submitted transactions to periodically retry initial
* broadcast
*/
std::set<TxId> m_unbroadcast_txids GUARDED_BY(cs);
/**
* Helper function to calculate all in-mempool ancestors of staged_ancestors
* and apply ancestor and descendant limits (including staged_ancestors
* themselves, entry_size and entry_count).
* param@[in] entry_size Virtual size to include in the limits.
* param@[in] entry_count How many entries to include in the
* limits.
* param@[in] staged_ancestors Should contain entries in the mempool.
* param@[out] setAncestors Will be populated with all mempool
* ancestors.
*/
bool CalculateAncestorsAndCheckLimits(
size_t entry_size, size_t entry_count, setEntries &setAncestors,
CTxMemPoolEntry::Parents &staged_ancestors, uint64_t limitAncestorCount,
uint64_t limitAncestorSize, uint64_t limitDescendantCount,
uint64_t limitDescendantSize, std::string &errString) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
public:
indirectmap<COutPoint, const CTransaction *> mapNextTx GUARDED_BY(cs);
std::map<TxId, Amount> mapDeltas GUARDED_BY(cs);
/**
* Create a new CTxMemPool.
* Sanity checks will be off by default for performance, because otherwise
* accepting transactions becomes O(N^2) where N is the number of
* transactions in the pool.
*
* @param[in] check_ratio is the ratio used to determine how often sanity
* checks will run.
*/
CTxMemPool(int check_ratio = 0);
~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 &active_coins_tip,
int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
// 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).
void addUnchecked(const CTxMemPoolEntry &entry)
EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
void addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAncestors)
EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason)
EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* After reorg, filter the entries that would no longer be valid in the
* next block, and update the entries' cached LockPoints if needed.
* The mempool does not have any knowledge of consensus rules. It just
* applies the callable function and removes the ones for which it
* returns true.
* @param[in] filter_final_and_mature Predicate that checks the
* relevant validation rules and updates an entry's LockPoints.
*/
void removeForReorg(const Config &config, CChain &chain,
std::function<bool(txiter)> filter_final_and_mature)
EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
void removeConflicts(const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
void removeForBlock(const std::vector<CTransactionRef> &vtx,
unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
void clear();
// lock free
void _clear() EXCLUSIVE_LOCKS_REQUIRED(cs);
bool CompareDepthAndScore(const TxId &txida, const TxId &txidb);
void queryHashes(std::vector<uint256> &vtxid) const;
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
EXCLUSIVE_LOCKS_REQUIRED(cs);
/** Affect CreateNewBlock prioritisation of transactions */
void PrioritiseTransaction(const TxId &txid, const Amount nFeeDelta);
void ApplyDelta(const TxId &txid, Amount &nFeeDelta) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
void ClearPrioritisation(const TxId &txid) EXCLUSIVE_LOCKS_REQUIRED(cs);
/** Get the transaction in the pool that spends the same prevout */
const CTransaction *GetConflictTx(const COutPoint &prevout) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
/** Returns an iterator to the given txid, if found */
std::optional<txiter> GetIter(const TxId &txid) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* Translate a set of txids into a set of pool iterators to avoid repeated
* lookups.
*/
setEntries GetIterSet(const std::set<TxId> &txids) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* 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) EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* UpdateTransactionsFromBlock is called 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).
* @post updated descendant state for descendants of each transaction in
* txidsToUpdate (excluding any child transactions present in
* txidsToUpdate, which are already accounted for). Updated state
* includes add fee/size information for such descendants to the
* parent and updated ancestor state to include the parent.
*
* @param[in] txidsToUpdate The set of txids from the
* disconnected block that have been accepted back into the mempool.
* @param[in] ancestor_size_limit The maximum allowed size in virtual
* bytes of an entry and its ancestors
* @param[in] ancestor_count_limit The maximum allowed number of
* transactions including the entry and its ancestors.
*/
void UpdateTransactionsFromBlock(const std::vector<TxId> &txidsToUpdate,
uint64_t ancestor_size_limit,
uint64_t ancestor_count_limit)
EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main) LOCKS_EXCLUDED(m_epoch);
/**
* 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
+ * or look up parents from m_parents. 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
EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* Calculate all in-mempool ancestors of a set of transactions not already
* in the mempool and check ancestor and descendant limits. Heuristics are
* used to estimate the ancestor and descendant count of all entries if the
* package were to be added to the mempool. The limits are applied to the
* union of all package transactions. For example, if the package has 3
* transactions and limitAncestorCount = 50, the union of all 3 sets of
* ancestors (including the transactions themselves) must be <= 47.
* @param[in] package Transaction package being
* evaluated for acceptance to mempool. The transactions need not be
* direct ancestors/descendants of each other.
* @param[in] limitAncestorCount Max number of txns including
* ancestors.
* @param[in] limitAncestorSize Max size including ancestors.
* @param[in] limitDescendantCount Max number of txns including
* descendants.
* @param[in] limitDescendantSize Max size including descendants.
* @param[out] errString Populated with error reason if
* a limit is hit.
*/
bool CheckPackageLimits(const Package &package, uint64_t limitAncestorCount,
uint64_t limitAncestorSize,
uint64_t limitDescendantCount,
uint64_t limitDescendantSize,
std::string &errString) const
EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* 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)
EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* Expire all transaction (and their dependencies) in the mempool older than
* time. Return the number of removed transactions.
*/
int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs);
/**
* Reduce the size of the mempool by expiring and then trimming the mempool.
*/
void LimitSize(CCoinsViewCache &coins_cache, size_t limit,
std::chrono::seconds age)
EXCLUSIVE_LOCKS_REQUIRED(cs, ::cs_main);
/**
* Calculate the ancestor and descendant count for the given transaction.
* The counts include the transaction itself.
* When ancestors is non-zero (ie, the transaction itself is in the
* mempool), ancestorsize and ancestorfees will also be set to the
* appropriate values.
*/
void GetTransactionAncestry(const TxId &txid, size_t &ancestors,
size_t &descendants,
size_t *ancestorsize = nullptr,
Amount *ancestorfees = nullptr) const;
/** @returns true if the mempool is fully loaded */
bool IsLoaded() const;
/** Sets the current loaded state */
void SetIsLoaded(bool loaded);
unsigned long size() const {
LOCK(cs);
return mapTx.size();
}
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
AssertLockHeld(cs);
return totalTxSize;
}
Amount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
AssertLockHeld(cs);
return m_total_fee;
}
bool exists(const TxId &txid) const {
LOCK(cs);
return mapTx.count(txid) != 0;
}
CTransactionRef get(const TxId &txid) const;
TxMempoolInfo info(const TxId &txid) const;
std::vector<TxMempoolInfo> infoAll() const;
CFeeRate estimateFee() const;
size_t DynamicMemoryUsage() const;
/** Adds a transaction to the unbroadcast set */
void AddUnbroadcastTx(const TxId &txid) {
LOCK(cs);
// Sanity check the transaction is in the mempool & insert into
// unbroadcast set.
if (exists(txid)) {
m_unbroadcast_txids.insert(txid);
}
}
/** Removes a transaction from the unbroadcast set */
void RemoveUnbroadcastTx(const TxId &txid, const bool unchecked = false);
/** Returns transactions in unbroadcast set */
std::set<TxId> GetUnbroadcastTxs() const {
LOCK(cs);
return m_unbroadcast_txids;
}
/** Returns whether a txid is in the unbroadcast set */
bool IsUnbroadcastTx(const TxId &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs) {
AssertLockHeld(cs);
return (m_unbroadcast_txids.count(txid) != 0);
}
/** Guards this internal counter for external reporting */
uint64_t GetAndIncrementSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
return m_sequence_number++;
}
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
return m_sequence_number;
}
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.
*
* @pre CTxMemPool::m_children is correct for the given tx and all
* descendants.
* @pre cachedDescendants is an accurate cache where each entry has all
* descendants of the corresponding key, including those that should
* be removed for violation of ancestor limits.
* @post if updateIt has any non-excluded descendants, cachedDescendants
* has a new cache line for updateIt.
* @post descendants_to_remove has a new entry for any descendant which
* exceeded ancestor limits relative to updateIt.
*
* @param[in] updateIt the entry to update for its descendants
* @param[in,out] cachedDescendants a cache where each line corresponds to
* all descendants. It 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.
* @param[in] setExclude 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).
* @param[out] descendants_to_remove Populated with the txids of entries
* that exceed ancestor limits. It's the responsibility of the caller
* to removeRecursive them.
* @param[in] ancestor_size_limit the max number of ancestral bytes allowed
* for any descendant
* @param[in] ancestor_count_limit the max number of ancestor transactions
* allowed for any descendant
*/
void UpdateForDescendants(txiter updateIt, cacheMap &cachedDescendants,
const std::set<TxId> &setExclude,
std::set<TxId> &descendants_to_remove,
uint64_t ancestor_size_limit,
uint64_t ancestor_count_limit)
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)
EXCLUSIVE_LOCKS_REQUIRED(cs);
public:
/**
* visited marks a CTxMemPoolEntry as having been traversed
* during the lifetime of the most recently created Epoch::Guard
* and returns false if we are the first visitor, true otherwise.
*
* An Epoch::Guard must be held when visited is called or an assert will be
* triggered.
*
*/
bool visited(const txiter it) const EXCLUSIVE_LOCKS_REQUIRED(cs, m_epoch) {
return m_epoch.visited(it->m_epoch_marker);
}
bool visited(std::optional<txiter> it) const
EXCLUSIVE_LOCKS_REQUIRED(cs, m_epoch) {
// verify guard even when it==nullopt
assert(m_epoch.guarded());
return !it || visited(*it);
}
};
/**
* CCoinsView that brings transactions from a mempool 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, are outputs from any mempool transaction, or are
* tracked temporarily to allow transaction dependencies in package validation.
* 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
* signrawtransactionwithkey and signrawtransactionwithwallet,
* as long as the conflicting transaction is not yet confirmed.
*/
class CCoinsViewMemPool : public CCoinsViewBacked {
/**
* Coins made available by transactions being validated. Tracking these
* allows for package validation, since we can access transaction outputs
* without submitting them to mempool.
*/
std::unordered_map<COutPoint, Coin, SaltedOutpointHasher> m_temp_added;
protected:
const CTxMemPool &mempool;
public:
CCoinsViewMemPool(CCoinsView *baseIn, const CTxMemPool &mempoolIn);
bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
/**
* Add the coins created by this transaction. These coins are only
* temporarily stored in m_temp_added and cannot be flushed to the back end.
* Only used for package validation.
*/
void PackageAddTransaction(const CTransactionRef &tx);
};
/**
* 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) EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
// 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, CTxMemPool &pool)
EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
// 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,
CChainState &active_chainstate,
bool fAddToMempool, CTxMemPool &pool)
EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs);
};
#endif // BITCOIN_TXMEMPOOL_H