CTxMemPool Class Reference

#include <txmempool.h>

Classes
struct	CompareIteratorByHash
struct	TxLinks

Public Types
typedef boost::multi_index_container< CTxMemPoolEntry, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< mempoolentry_txid, SaltedTxidHasher >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< descendant_score >, boost::multi_index::identity< CTxMemPoolEntry >, CompareTxMemPoolEntryByDescendantScore >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< entry_time >, boost::multi_index::identity< CTxMemPoolEntry >, CompareTxMemPoolEntryByEntryTime >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< ancestor_score >, boost::multi_index::identity< CTxMemPoolEntry >, CompareTxMemPoolEntryByAncestorFee > > >	indexed_transaction_set
using	txiter = indexed_transaction_set::nth_index< 0 >::type::const_iterator
typedef std::set< txiter, CompareIteratorByHash >	setEntries

Public Member Functions
indexed_transaction_set mapTx	GUARDED_BY (cs)
std::vector< std::pair< uint256, txiter > > vTxHashes	GUARDED_BY (cs)
	All tx witness hashes/entries in mapTx, in random order. More...
const setEntries &	GetMemPoolParents (txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs)
const setEntries &	GetMemPoolChildren (txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs)
uint64_t	CalculateDescendantMaximum (txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs)
indirectmap< COutPoint, const CTransaction * > mapNextTx	GUARDED_BY (cs)
	CTxMemPool (CBlockPolicyEstimator *estimator=nullptr)
void	check (const CCoinsViewCache *pcoins) const
void	setSanityCheck (double dFrequency=1.0)
void	addUnchecked (const CTxMemPoolEntry &entry, bool validFeeEstimate=true) EXCLUSIVE_LOCKS_REQUIRED(cs
void	addUnchecked (const CTxMemPoolEntry &entry, setEntries &setAncestors, bool validFeeEstimate=true) EXCLUSIVE_LOCKS_REQUIRED(cs
void	removeRecursive (const CTransaction &tx, MemPoolRemovalReason reason=MemPoolRemovalReason::UNKNOWN) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	removeForReorg (const CCoinsViewCache *pcoins, unsigned int nMemPoolHeight, int flags) EXCLUSIVE_LOCKS_REQUIRED(cs
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 ()
void	_clear () EXCLUSIVE_LOCKS_REQUIRED(cs)
bool	CompareDepthAndScore (const uint256 &hasha, const uint256 &hashb)
void	queryHashes (std::vector< uint256 > &vtxid) const
bool	isSpent (const COutPoint &outpoint) const
unsigned int	GetTransactionsUpdated () const
void	AddTransactionsUpdated (unsigned int n)
bool	HasNoInputsOf (const CTransaction &tx) const EXCLUSIVE_LOCKS_REQUIRED(cs)
void	PrioritiseTransaction (const uint256 &hash, const CAmount &nFeeDelta)
void	ApplyDelta (const uint256 hash, CAmount &nFeeDelta) const
void	ClearPrioritisation (const uint256 hash)
const CTransaction *	GetConflictTx (const COutPoint &prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs)
boost::optional< txiter >	GetIter (const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
setEntries	GetIterSet (const std::set< uint256 > &hashes) const EXCLUSIVE_LOCKS_REQUIRED(cs)
void	RemoveStaged (setEntries &stage, bool updateDescendants, MemPoolRemovalReason reason=MemPoolRemovalReason::UNKNOWN) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	UpdateTransactionsFromBlock (const std::vector< uint256 > &vHashesToUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs
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)
void	CalculateDescendants (txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
CFeeRate	GetMinFee (size_t sizelimit) const
void	TrimToSize (size_t sizelimit, std::vector< COutPoint > *pvNoSpendsRemaining=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs)
int	Expire (int64_t time) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	GetTransactionAncestry (const uint256 &txid, size_t &ancestors, size_t &descendants) const
bool	IsLoaded () const
void	SetIsLoaded (bool loaded)
unsigned long	size () const
uint64_t	GetTotalTxSize () const
bool	exists (const uint256 &hash) const
CTransactionRef	get (const uint256 &hash) const
TxMempoolInfo	info (const uint256 &hash) const
std::vector< TxMempoolInfo >	infoAll () const
size_t	DynamicMemoryUsage () const

Public Attributes
RecursiveMutex	cs
std::map< uint256, CAmount >	mapDeltas
void	cs_main
boost::signals2::signal< void(CTransactionRef)>	NotifyEntryAdded
boost::signals2::signal< void(CTransactionRef, MemPoolRemovalReason)>	NotifyEntryRemoved

Static Public Attributes
static const int	ROLLING_FEE_HALFLIFE = 60 * 60 * 12

Private Types
typedef std::map< txiter, setEntries, CompareIteratorByHash >	cacheMap
typedef std::map< txiter, TxLinks, CompareIteratorByHash >	txlinksMap

Private Member Functions
uint32_t nCheckFrequency	GUARDED_BY (cs)
	Value n means that n times in 2^32 we check. More...
void	trackPackageRemoved (const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs)
bool m_is_loaded	GUARDED_BY (cs)
void	UpdateParent (txiter entry, txiter parent, bool add)
void	UpdateChild (txiter entry, txiter child, bool add)
std::vector< indexed_transaction_set::const_iterator >	GetSortedDepthAndScore () const EXCLUSIVE_LOCKS_REQUIRED(cs)
void	UpdateForDescendants (txiter updateIt, cacheMap &cachedDescendants, const std::set< uint256 > &setExclude) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	UpdateAncestorsOf (bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	UpdateEntryForAncestors (txiter it, const setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	UpdateForRemoveFromMempool (const setEntries &entriesToRemove, bool updateDescendants) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	UpdateChildrenForRemoval (txiter entry) EXCLUSIVE_LOCKS_REQUIRED(cs)
void	removeUnchecked (txiter entry, MemPoolRemovalReason reason=MemPoolRemovalReason::UNKNOWN) EXCLUSIVE_LOCKS_REQUIRED(cs)

Private Attributes
std::atomic< unsigned int >	nTransactionsUpdated
	Used by getblocktemplate to trigger CreateNewBlock() invocation. More...
CBlockPolicyEstimator *	minerPolicyEstimator
uint64_t	totalTxSize
	sum of all mempool tx's virtual sizes. Differs from serialized tx size since witness data is discounted. Defined in BIP 141. More...
uint64_t	cachedInnerUsage
	sum of dynamic memory usage of all the map elements (NOT the maps themselves) More...
int64_t	lastRollingFeeUpdate
bool	blockSinceLastRollingFeeBump
double	rollingMinimumFeeRate
	minimum fee to get into the pool, decreases exponentially More...
txlinksMap	mapLinks

Detailed Description

CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the next block.

Transactions are added when they are seen on the network (or created by the local node), but not all transactions seen are added to the pool. For example, the following new transactions will not be added to the mempool:

• a transaction which doesn't meet the minimum fee requirements.
• a new transaction that double-spends an input of a transaction already in the pool where the new transaction does not meet the Replace-By-Fee requirements as defined in BIP 125.
• a non-standard transaction.

CTxMemPool::mapTx, and CTxMemPoolEntry bookkeeping:

mapTx is a boost::multi_index that sorts the mempool on 4 criteria:

• transaction hash
• 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.

Usually when a new transaction is added to the mempool, it has no in-mempool children (because any such children would be an orphan). So in addUnchecked(), we:

• update a new entry's setMemPoolParents to include all in-mempool parents
• update the new entry's direct parents to include the new tx as a child
• update all ancestors of the transaction to include the new tx's size/fee

When a transaction is removed from the mempool, we must:

• update all in-mempool parents to not track the tx in setMemPoolChildren
• update all ancestors to not include the tx's size/fees in descendant state
• update all in-mempool children to not include it as a parent

These happen in UpdateForRemoveFromMempool(). (Note that when removing a transaction along with its descendants, we must calculate that set of transactions to be removed before doing the removal, or else the mempool can be in an inconsistent state where it's impossible to walk the ancestors of a transaction.)

In the event of a reorg, the assumption that a newly added tx has no in-mempool children is false. In particular, the mempool is in an inconsistent state while new transactions are being added, because there may be descendant transactions of a tx coming from a disconnected block that are unreachable from just looking at transactions in the mempool (the linking transactions may also be in the disconnected block, waiting to be added). Because of this, there's not much benefit in trying to search for in-mempool children in addUnchecked(). Instead, in the special case of transactions being added from a disconnected block, we require the caller to clean up the state, to account for in-mempool, out-of-block descendants for all the in-block transactions by calling UpdateTransactionsFromBlock(). Note that until this is called, the mempool state is not consistent, and in particular mapLinks may not be correct (and therefore functions like CalculateMemPoolAncestors() and CalculateDescendants() that rely on them to walk the mempool are not generally safe to use).

Computational limits:

Updating all in-mempool ancestors of a newly added transaction can be slow, if no bound exists on how many in-mempool ancestors there may be. CalculateMemPoolAncestors() takes configurable limits that are designed to prevent these calculations from being too CPU intensive.

Member Typedef Documentation

cacheMap

typedef std::map<txiter, setEntries, CompareIteratorByHash> CTxMemPool::cacheMap

private

indexed_transaction_set

typedef boost::multi_index_container< CTxMemPoolEntry, boost::multi_index::indexed_by< boost::multi_index::hashed_unique<mempoolentry_txid, SaltedTxidHasher>, boost::multi_index::ordered_non_unique< boost::multi_index::tag<descendant_score>, boost::multi_index::identity<CTxMemPoolEntry>, CompareTxMemPoolEntryByDescendantScore >, boost::multi_index::ordered_non_unique< boost::multi_index::tag<entry_time>, boost::multi_index::identity<CTxMemPoolEntry>, CompareTxMemPoolEntryByEntryTime >, boost::multi_index::ordered_non_unique< boost::multi_index::tag<ancestor_score>, boost::multi_index::identity<CTxMemPoolEntry>, CompareTxMemPoolEntryByAncestorFee > > > CTxMemPool::indexed_transaction_set

setEntries

typedef std::set<txiter, CompareIteratorByHash> CTxMemPool::setEntries

txiter

using CTxMemPool::txiter = indexed_transaction_set::nth_index<0>::type::const_iterator

txlinksMap

typedef std::map<txiter, TxLinks, CompareIteratorByHash> CTxMemPool::txlinksMap

private

Constructor & Destructor Documentation

CTxMemPool()

CTxMemPool::CTxMemPool ( CBlockPolicyEstimator *  estimator = nullptr )

explicit

Create a new CTxMemPool.

Member Function Documentation

_clear()

void CTxMemPool::_clear

(

)

AddTransactionsUpdated()

void CTxMemPool::AddTransactionsUpdated

(

unsigned int

n

)

addUnchecked() [1/2]

void CTxMemPool::addUnchecked	(	const CTxMemPoolEntry &	entry,
		bool	validFeeEstimate = true
	)

addUnchecked() [2/2]

void CTxMemPool::addUnchecked	(	const CTxMemPoolEntry &	entry,
		setEntries &	setAncestors,
		bool	validFeeEstimate = true
	)

ApplyDelta()

void CTxMemPool::ApplyDelta	(	const uint256	hash,
		CAmount &	nFeeDelta
	)		const

CalculateDescendantMaximum()

uint64_t CTxMemPool::CalculateDescendantMaximum

(

txiter

entry

)

const

CalculateDescendants()

void CTxMemPool::CalculateDescendants	(	txiter	it,
		setEntries &	setDescendants
	)		const

Populate setDescendants with all in-mempool descendants of hash. Assumes that setDescendants includes all in-mempool descendants of anything already in it.

CalculateMemPoolAncestors()

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

Try to calculate all in-mempool ancestors of entry. (these are all calculated including the tx itself) limitAncestorCount = max number of ancestors limitAncestorSize = max size of ancestors limitDescendantCount = max number of descendants any ancestor can have limitDescendantSize = max size of descendants any ancestor can have errString = populated with error reason if any limits are hit fSearchForParents = whether to search a tx's vin for in-mempool parents, or look up parents from mapLinks. Must be true for entries not in the mempool

check()

void CTxMemPool::check

(

const CCoinsViewCache *

pcoins

)

const

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.

clear()

void CTxMemPool::clear

(

)

ClearPrioritisation()

void CTxMemPool::ClearPrioritisation

(

const uint256

hash

)

CompareDepthAndScore()

bool CTxMemPool::CompareDepthAndScore	(	const uint256 &	hasha,
		const uint256 &	hashb
	)

DynamicMemoryUsage()

size_t CTxMemPool::DynamicMemoryUsage

(

)

const

exists()

bool CTxMemPool::exists ( const uint256 &  hash ) const

inline

Expire()

int CTxMemPool::Expire

(

int64_t

time

)

Expire all transaction (and their dependencies) in the mempool older than time. Return the number of removed transactions.

get()

CTransactionRef CTxMemPool::get

(

const uint256 &

hash

)

const

GetConflictTx()

const CTransaction * CTxMemPool::GetConflictTx

(

const COutPoint &

prevout

)

const

Get the transaction in the pool that spends the same prevout

GetIter()

boost::optional< CTxMemPool::txiter > CTxMemPool::GetIter

(

const uint256 &

txid

)

const

Returns an iterator to the given hash, if found

GetIterSet()

CTxMemPool::setEntries CTxMemPool::GetIterSet

(

const std::set< uint256 > &

hashes

)

const

Translate a set of hashes into a set of pool iterators to avoid repeated lookups

GetMemPoolChildren()

const CTxMemPool::setEntries & CTxMemPool::GetMemPoolChildren

(

txiter

entry

)

const

GetMemPoolParents()

const CTxMemPool::setEntries & CTxMemPool::GetMemPoolParents

(

txiter

entry

)

const

GetMinFee()

CFeeRate CTxMemPool::GetMinFee

(

size_t

sizelimit

)

const

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.

GetSortedDepthAndScore()

std::vector< CTxMemPool::indexed_transaction_set::const_iterator > CTxMemPool::GetSortedDepthAndScore ( ) const

private

GetTotalTxSize()

uint64_t CTxMemPool::GetTotalTxSize ( ) const

inline

GetTransactionAncestry()

void CTxMemPool::GetTransactionAncestry	(	const uint256 &	txid,
		size_t &	ancestors,
		size_t &	descendants
	)		const

Calculate the ancestor and descendant count for the given transaction. The counts include the transaction itself.

GetTransactionsUpdated()

unsigned int CTxMemPool::GetTransactionsUpdated

(

)

const

GUARDED_BY() [1/5]

uint32_t nCheckFrequency CTxMemPool::GUARDED_BY ( cs  )

private

Value n means that n times in 2^32 we check.

GUARDED_BY() [2/5]

bool m_is_loaded CTxMemPool::GUARDED_BY ( cs  )

inlineprivate

GUARDED_BY() [3/5]

indexed_transaction_set mapTx CTxMemPool::GUARDED_BY

(

cs

)

GUARDED_BY() [4/5]

std::vector<std::pair<uint256, txiter> > vTxHashes CTxMemPool::GUARDED_BY

(

cs

)

All tx witness hashes/entries in mapTx, in random order.

GUARDED_BY() [5/5]

indirectmap<COutPoint, const CTransaction*> mapNextTx CTxMemPool::GUARDED_BY

(

cs

)

HasNoInputsOf()

bool CTxMemPool::HasNoInputsOf

(

const CTransaction &

tx

)

const

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.

info()

TxMempoolInfo CTxMemPool::info

(

const uint256 &

hash

)

const

infoAll()

std::vector< TxMempoolInfo > CTxMemPool::infoAll

(

)

const

IsLoaded()

bool CTxMemPool::IsLoaded

(

)

const

Returns

true if the mempool is fully loaded

isSpent()

bool CTxMemPool::isSpent

(

const COutPoint &

outpoint

)

const

PrioritiseTransaction()

void CTxMemPool::PrioritiseTransaction	(	const uint256 &	hash,
		const CAmount &	nFeeDelta
	)

Affect CreateNewBlock prioritisation of transactions

queryHashes()

void CTxMemPool::queryHashes

(

std::vector< uint256 > &

vtxid

)

const

removeConflicts()

void CTxMemPool::removeConflicts

(

const CTransaction &

tx

)

removeForBlock()

void CTxMemPool::removeForBlock	(	const std::vector< CTransactionRef > &	vtx,
		unsigned int	nBlockHeight
	)

Called when a block is connected. Removes from mempool and updates the miner fee estimator.

removeForReorg()

void CTxMemPool::removeForReorg	(	const CCoinsViewCache *	pcoins,
		unsigned int	nMemPoolHeight,
		int	flags
	)

removeRecursive()

void CTxMemPool::removeRecursive	(	const CTransaction &	tx,
		MemPoolRemovalReason	reason = MemPoolRemovalReason::UNKNOWN
	)

RemoveStaged()

void CTxMemPool::RemoveStaged	(	setEntries &	stage,
		bool	updateDescendants,
		MemPoolRemovalReason	reason = MemPoolRemovalReason::UNKNOWN
	)

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.

removeUnchecked()

void CTxMemPool::removeUnchecked ( txiter  entry, MemPoolRemovalReason  reason = MemPoolRemovalReason::UNKNOWN  )

private

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.

SetIsLoaded()

void CTxMemPool::SetIsLoaded

(

bool

loaded

)

Sets the current loaded state

setSanityCheck()

void CTxMemPool::setSanityCheck ( double  dFrequency = 1.0 )

inline

size()

unsigned long CTxMemPool::size ( ) const

inline

trackPackageRemoved()

void CTxMemPool::trackPackageRemoved ( const CFeeRate &  rate )

private

TrimToSize()

void CTxMemPool::TrimToSize	(	size_t	sizelimit,
		std::vector< COutPoint > *	pvNoSpendsRemaining = nullptr
	)

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.

UpdateAncestorsOf()

void CTxMemPool::UpdateAncestorsOf ( bool  add, txiter  hash, setEntries &  setAncestors  )

private

Update ancestors of hash to add/remove it as a descendant transaction.

UpdateChild()

void CTxMemPool::UpdateChild ( txiter  entry, txiter  child, bool  add  )

private

UpdateChildrenForRemoval()

void CTxMemPool::UpdateChildrenForRemoval ( txiter  entry )

private

Sever link between specified transaction and direct children.

UpdateEntryForAncestors()

void CTxMemPool::UpdateEntryForAncestors ( txiter  it, const setEntries &  setAncestors  )

private

Set ancestor state for an entry

UpdateForDescendants()

void CTxMemPool::UpdateForDescendants ( txiter  updateIt, cacheMap &  cachedDescendants, const std::set< uint256 > &  setExclude  )

private

UpdateForDescendants is used by UpdateTransactionsFromBlock to update the descendants for a single transaction that has been added to the mempool but may have child transactions in the mempool, eg during a chain reorg. setExclude is the set of descendant transactions in the mempool that must not be accounted for (because any descendants in setExclude were added to the mempool after the transaction being updated and hence their state is already reflected in the parent state).

cachedDescendants will be updated with the descendants of the transaction being updated, so that future invocations don't need to walk the same transaction again, if encountered in another transaction chain.

UpdateForRemoveFromMempool()

void CTxMemPool::UpdateForRemoveFromMempool ( const setEntries &  entriesToRemove, bool  updateDescendants  )

private

For each transaction being removed, update ancestors and any direct children. If updateDescendants is true, then also update in-mempool descendants' ancestor state.

UpdateParent()

void CTxMemPool::UpdateParent ( txiter  entry, txiter  parent, bool  add  )

private

UpdateTransactionsFromBlock()

void CTxMemPool::UpdateTransactionsFromBlock

(

const std::vector< uint256 > &

vHashesToUpdate

)

When adding transactions from a disconnected block back to the mempool, new mempool entries may have children in the mempool (which is generally not the case when otherwise adding transactions). UpdateTransactionsFromBlock() will find child transactions and update the descendant state for each transaction in vHashesToUpdate (excluding any child transactions present in vHashesToUpdate, which are already accounted for). Note: vHashesToUpdate should be the set of transactions from the disconnected block that have been accepted back into the mempool.

Member Data Documentation

blockSinceLastRollingFeeBump

bool CTxMemPool::blockSinceLastRollingFeeBump

mutableprivate

cachedInnerUsage

uint64_t CTxMemPool::cachedInnerUsage

private

sum of dynamic memory usage of all the map elements (NOT the maps themselves)

cs

RecursiveMutex CTxMemPool::cs

mutable

This mutex needs to be locked when accessing mapTx or other members that are guarded by it.

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 (ChainActive() and pcoinsTip) 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.

cs_main

void CTxMemPool::cs_main

lastRollingFeeUpdate

int64_t CTxMemPool::lastRollingFeeUpdate

mutableprivate

mapDeltas

std::map<uint256, CAmount> CTxMemPool::mapDeltas

mapLinks

txlinksMap CTxMemPool::mapLinks

private

minerPolicyEstimator

CBlockPolicyEstimator* CTxMemPool::minerPolicyEstimator

private

NotifyEntryAdded

boost::signals2::signal<void (CTransactionRef)> CTxMemPool::NotifyEntryAdded

NotifyEntryRemoved

boost::signals2::signal<void (CTransactionRef, MemPoolRemovalReason)> CTxMemPool::NotifyEntryRemoved

nTransactionsUpdated

std::atomic<unsigned int> CTxMemPool::nTransactionsUpdated

private

Used by getblocktemplate to trigger CreateNewBlock() invocation.

ROLLING_FEE_HALFLIFE

const int CTxMemPool::ROLLING_FEE_HALFLIFE = 60 * 60 * 12

static

rollingMinimumFeeRate

double CTxMemPool::rollingMinimumFeeRate

mutableprivate

minimum fee to get into the pool, decreases exponentially

totalTxSize

uint64_t CTxMemPool::totalTxSize

private

sum of all mempool tx's virtual sizes. Differs from serialized tx size since witness data is discounted. Defined in BIP 141.

---

The documentation for this class was generated from the following files:

• src/txmempool.h
• src/txmempool.cpp