#include <disconnected_transactions.h>

Public Member Functions
	DisconnectedBlockTransactions (size_t max_mem_usage)

	~DisconnectedBlockTransactions ()

size_t	DynamicMemoryUsage () const

std::vector< CTransactionRef >	AddTransactionsFromBlock (const std::vector< CTransactionRef > &vtx)
	Add transactions from the block, iterating through vtx in reverse order. More...

void	removeForBlock (const std::vector< CTransactionRef > &vtx)
	Remove any entries that are in this block. More...

size_t	size () const

void	clear ()

std::list< CTransactionRef >	take ()
	Clear all data structures and return the list of transactions. More...

Private Types
using	TxList = decltype(queuedTx)

Private Member Functions
std::vector< CTransactionRef >	LimitMemoryUsage ()
	Trim the earliest-added entries until we are within memory bounds. More...

Private Attributes
uint64_t	cachedInnerUsage = 0
	Cached dynamic memory usage for the `CTransactionRef`s. More...

const size_t	m_max_mem_usage

std::list< CTransactionRef >	queuedTx

std::unordered_map< uint256, TxList::iterator, SaltedTxidHasher >	iters_by_txid

Detailed Description

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.

Order of queuedTx: The front of the list should be the most recently-confirmed transactions (transactions at the end of vtx of blocks closer to the tip). If memory usage grows too large, we trim from the front of the list. After trimming, transactions can be re-added to the mempool from the back of the list to the front without running into missing inputs.

Definition at line 37 of file disconnected_transactions.h.

Member Typedef Documentation

◆ TxList

using DisconnectedBlockTransactions::TxList = decltype(queuedTx)

private

Definition at line 43 of file disconnected_transactions.h.

Constructor & Destructor Documentation

◆ DisconnectedBlockTransactions()

DisconnectedBlockTransactions::DisconnectedBlockTransactions ( size_t max_mem_usage )

inline

Definition at line 50 of file disconnected_transactions.h.

◆ ~DisconnectedBlockTransactions()

DisconnectedBlockTransactions::~DisconnectedBlockTransactions ( )

Definition at line 24 of file disconnected_transactions.cpp.

Here is the call graph for this function:

Member Function Documentation

◆ AddTransactionsFromBlock()

std::vector< CTransactionRef > DisconnectedBlockTransactions::AddTransactionsFromBlock ( const std::vector< CTransactionRef > & vtx )

Add transactions from the block, iterating through vtx in reverse order.

Callers should call this function for blocks in descending order by block height. We assume that callers never pass multiple transactions with the same txid, otherwise things can go very wrong in removeForBlock due to queuedTx containing an item without a corresponding entry in iters_by_txid.