Transaction pool, handles transactions which are not part of a block. More...

#include <tx_pool.h>

Inheritance diagram for cryptonote::tx_memory_pool:

Collaboration diagram for cryptonote::tx_memory_pool:

Classes
struct	tx_details
	information about a single transaction More...
struct	removed_tx_info

Public Member Functions
	tx_memory_pool (Blockchain &bchs)
	Constructor.
bool	add_tx (transaction &tx, const crypto::hash &id, const cryptonote::blobdata &blob, size_t tx_weight, tx_verification_context &tvc, relay_method tx_relay, bool relayed, uint8_t version, uint8_t nic_verified_hf_version=0)
bool	add_tx (transaction &tx, tx_verification_context &tvc, relay_method tx_relay, bool relayed, uint8_t version, uint8_t nic_verified_hf_version=0)
	add a transaction to the transaction pool
bool	take_tx (const crypto::hash &id, transaction &tx, cryptonote::blobdata &txblob, size_t &tx_weight, uint64_t &fee, bool &relayed, bool &do_not_relay, bool &double_spend_seen, bool &pruned, bool suppress_missing_msgs=false)
	takes a transaction with the given hash from the pool
bool	have_tx (const crypto::hash &id, relay_category tx_category) const
	checks if the pool has a transaction with the given hash
bool	on_blockchain_inc (uint64_t new_block_height, const crypto::hash &top_block_id)
	action to take when notified of a block added to the blockchain
bool	on_blockchain_dec (uint64_t new_block_height, const crypto::hash &top_block_id)
	action to take when notified of a block removed from the blockchain
void	on_idle ()
	action to take periodically
void	lock () const
	locks the transaction pool
void	unlock () const
	unlocks the transaction pool
bool	init (size_t max_txpool_weight=0, bool mine_stem_txes=false)
	loads pool state (if any) from disk, and initializes pool
bool	deinit ()
	attempts to save the transaction pool state to disk
bool	fill_block_template (block &bl, size_t median_weight, uint64_t already_generated_coins, size_t &total_weight, uint64_t &fee, uint64_t &expected_reward, uint8_t version)
	Chooses transactions for a block to include.
void	get_transactions (std::vector< transaction > &txs, bool include_sensitive=false) const
	get a list of all transactions in the pool
void	get_transaction_hashes (std::vector< crypto::hash > &txs, bool include_sensitive=false) const
	get a list of all transaction hashes in the pool
void	get_transaction_backlog (std::vector< tx_backlog_entry > &backlog, bool include_sensitive=false) const
	get (weight, fee, receive time) for all transaction in the pool
void	get_block_template_backlog (std::vector< tx_block_template_backlog_entry > &backlog, bool include_sensitive=false) const
	get (hash, weight, fee) for transactions in the pool - the minimum required information to create a block template
void	get_transaction_stats (struct txpool_stats &stats, bool include_sensitive=false) const
	get a summary statistics of all transaction hashes in the pool
bool	get_transactions_and_spent_keys_info (std::vector< tx_info > &tx_infos, std::vector< spent_key_image_info > &key_image_infos, bool include_sensitive_data=false) const
	get information about all transactions and key images in the pool
bool	get_pool_for_rpc (std::vector< cryptonote::rpc::tx_in_pool > &tx_infos, cryptonote::rpc::key_images_with_tx_hashes &key_image_infos) const
	get information about all transactions and key images in the pool
bool	check_for_key_images (const std::vector< crypto::key_image > &key_images, std::vector< bool > &spent) const
	check for presence of key images in the pool
bool	get_transaction (const crypto::hash &h, cryptonote::blobdata &txblob, relay_category tx_category) const
	get a specific transaction from the pool
bool	get_relayable_transactions (std::vector< std::tuple< crypto::hash, cryptonote::blobdata, relay_method > > &txs)
	get a list of all relayable transactions and their hashes
void	set_relayed (epee::span< const crypto::hash > hashes, relay_method tx_relay, std::vector< bool > &just_broadcasted)
	tell the pool that certain transactions were just relayed
size_t	get_transactions_count (bool include_sensitive=false) const
	get the total number of transactions in the pool
std::string	print_pool (bool short_format) const
	get a string containing human-readable pool information
size_t	validate (uint8_t version)
	remove transactions from the pool which are no longer valid
uint64_t	cookie () const
	return the cookie
size_t	get_txpool_weight () const
	get the cumulative txpool weight in bytes
void	set_txpool_max_weight (size_t bytes)
	set the max cumulative txpool weight in bytes
void	reduce_txpool_weight (size_t weight)
	reduce the cumulative txpool weight by the weight provided
bool	get_transaction_info (const crypto::hash &txid, tx_details &td, bool include_sensitive_data, bool include_blob=false) const
	get infornation about a single transaction
bool	get_transactions_info (const std::vector< crypto::hash > &txids, std::vector< std::pair< crypto::hash, tx_details > > &txs, bool include_sensitive_data=false) const
	get information about multiple transactions
bool	get_complement (const std::vector< crypto::hash > &hashes, std::vector< cryptonote::blobdata > &txes) const
	get transactions not in the passed set
bool	get_pool_info (time_t start_time, bool include_sensitive, size_t max_tx_count, std::vector< std::pair< crypto::hash, tx_details > > &added_txs, std::vector< crypto::hash > &remaining_added_txids, std::vector< crypto::hash > &removed_txs, bool &incremental) const
	get info necessary for update of pool-related info in a wallet, preferably incremental

Private Types
typedef std::unordered_map< crypto::key_image, std::unordered_set< crypto::hash > >	key_images_container
	map key images to transactions which spent them

Private Member Functions
bool	insert_key_images (const transaction_prefix &tx, const crypto::hash &txid, relay_method tx_relay)
	insert key images into m_spent_key_images
bool	remove_stuck_transactions ()
	remove old transactions from the pool
bool	have_tx_keyimg_as_spent (const crypto::key_image &key_im, const crypto::hash &txid) const
	check if a transaction in the pool has a given spent key image
bool	have_tx_keyimges_as_spent (const transaction &tx, const crypto::hash &txid) const
	check if any spent key image in a transaction is in the pool
bool	remove_transaction_keyimages (const transaction_prefix &tx, const crypto::hash &txid)
	forget a transaction's spent key images
bool	is_transaction_ready_to_go (txpool_tx_meta_t &txd, const crypto::hash &txid, const cryptonote::blobdata_ref &txblob, transaction &tx) const
	check if a transaction is a valid candidate for inclusion in a block
bool	is_transaction_ready_to_go (txpool_tx_meta_t &txd, const crypto::hash &txid, const cryptonote::blobdata &txblob, transaction &tx) const
void	mark_double_spend (const transaction &tx)
	mark all transactions double spending the one passed
void	prune (size_t bytes=0)
	prune lowest fee/byte txes till we're not above bytes
void	add_tx_to_transient_lists (const crypto::hash &txid, double fee, time_t receive_time)
void	remove_tx_from_transient_lists (const cryptonote::sorted_tx_container::iterator &sorted_it, const crypto::hash &txid, bool sensitive)
void	track_removed_tx (const crypto::hash &txid, bool sensitive)
sorted_tx_container::iterator	find_tx_in_sorted_container (const crypto::hash &id) const
	get an iterator to a transaction in the sorted container
bool	check_tx_inputs (const std::function< cryptonote::transaction &(void)> &get_tx, const crypto::hash &txid, uint64_t &max_used_block_height, crypto::hash &max_used_block_id, tx_verification_context &tvc, bool kept_by_block=false) const
	cache/call Blockchain::check_tx_inputs results

Static Private Member Functions
static bool	have_key_images (const std::unordered_set< crypto::key_image > &kic, const transaction_prefix &tx)
	check if any of a transaction's spent key images are present in a given set
static bool	append_key_images (std::unordered_set< crypto::key_image > &kic, const transaction_prefix &tx)
	append the key images from a transaction to the given set

Private Attributes
epee::critical_section	m_transactions_lock
	lock for the pool
key_images_container	m_spent_key_images
	container for spent key images from the transactions in the pool
epee::math_helper::once_a_time_seconds< 30 >	m_remove_stuck_tx_interval
	interval on which to check for stale/"stuck" transactions
sorted_tx_container	m_txs_by_fee_and_receive_time
	< container for transactions organized by fee per size and receive time
std::atomic< uint64_t >	m_cookie
	incremented at each change
std::unordered_map< crypto::hash, time_t >	m_added_txs_by_id
time_t	m_added_txs_start_time
std::multimap< time_t, removed_tx_info >	m_removed_txs_by_time
time_t	m_removed_txs_start_time
std::unordered_set< crypto::hash >	m_timed_out_transactions
	transactions which are unlikely to be included in blocks
Blockchain &	m_blockchain
	reference to the Blockchain object
size_t	m_txpool_max_weight
size_t	m_txpool_weight
bool	m_mine_stem_txes
std::unordered_map< crypto::hash, std::tuple< bool, tx_verification_context, uint64_t, crypto::hash > >	m_input_cache
std::unordered_map< crypto::hash, transaction >	m_parsed_tx_cache
std::atomic< time_t >	m_next_check
	Next timestamp that a DB check for relayable txes is allowed.

Detailed Description

Transaction pool, handles transactions which are not part of a block.

This class handles all transactions which have been received, but not as part of a block.

This handling includes: storing the transactions organizing the transactions by fee per weight unit taking/giving transactions to and from various other components saving the transactions to disk on shutdown helping create a new block template by choosing transactions for it

Member Typedef Documentation

◆ key_images_container

typedef std::unordered_map<crypto::key_image, std::unordered_set<crypto::hash> > cryptonote::tx_memory_pool::key_images_container

private

map key images to transactions which spent them

this seems odd, but it seems that multiple transactions can exist in the pool which both have the same spent key. This would happen in the event of a reorg where someone creates a new/different transaction on the assumption that the original will not be in a block again.

Constructor & Destructor Documentation

◆ tx_memory_pool()

cryptonote::tx_memory_pool::tx_memory_pool ( Blockchain & bchs )

Constructor.

Parameters

bchs	a Blockchain class instance, for getting chain info

Member Function Documentation

◆ add_tx() [1/2]

bool cryptonote::tx_memory_pool::add_tx	(	transaction &	tx,
		const crypto::hash &	id,
		const cryptonote::blobdata &	blob,
		size_t	tx_weight,
		tx_verification_context &	tvc,
		relay_method	tx_relay,
		bool	relayed,
		uint8_t	version,
		uint8_t	nic_verified_hf_version = 0 )

Parameters

id	the transaction's hash @tx_relay how the transaction was received
tx_weight	the transaction's weight

◆ add_tx() [2/2]

bool cryptonote::tx_memory_pool::add_tx	(	transaction &	tx,
		tx_verification_context &	tvc,
		relay_method	tx_relay,
		bool	relayed,
		uint8_t	version,
		uint8_t	nic_verified_hf_version = 0 )

add a transaction to the transaction pool

Most likely the transaction will come from the network, but it is also possible for transactions to come from popped blocks during a reorg, or from local clients creating a transaction and submitting it to the network

Parameters

tx	the transaction to be added
tvc	return-by-reference status about the transaction verification @tx_relay how the transaction was received
relayed	was this transaction from the network or a local client?
version	the version used to create the transaction
nic_verified_hf_version	hard fork which "tx" is known to pass non-input consensus test

If "nic_verified_hf_version" parameter is equal to "version" parameter, then we skip the asserting ver_non_input_consensus(tx), which greatly speeds up block popping and returning txs to mempool for txs which we know will pass the test. If nothing is known about how "tx" passes the non-input consensus tests (e.g. for newly received relayed txs), then leave "nic_verified_hf_version" as its default value of 0 (there is no v0 fork).

Returns: true if the transaction passes validations, otherwise false

◆ add_tx_to_transient_lists()

void cryptonote::tx_memory_pool::add_tx_to_transient_lists	(	const crypto::hash &	txid,
		double	fee,
		time_t	receive_time )

private

◆ append_key_images()

bool cryptonote::tx_memory_pool::append_key_images	(	std::unordered_set< crypto::key_image > &	kic,
		const transaction_prefix &	tx )

staticprivate

append the key images from a transaction to the given set

Parameters

kic	the set of key images to append to
tx	the transaction

Returns: false if any append fails, otherwise true

◆ check_for_key_images()

bool cryptonote::tx_memory_pool::check_for_key_images	(	const std::vector< crypto::key_image > &	key_images,
		std::vector< bool > &	spent ) const

check for presence of key images in the pool

Parameters

key_images	[in] vector of key images to check
spent	[out] vector of bool to return

Returns: true

◆ check_tx_inputs()

bool cryptonote::tx_memory_pool::check_tx_inputs	(	const std::function< cryptonote::transaction &(void)> &	get_tx,
		const crypto::hash &	txid,
		uint64_t &	max_used_block_height,
		crypto::hash &	max_used_block_id,
		tx_verification_context &	tvc,
		bool	kept_by_block = false ) const

private

cache/call Blockchain::check_tx_inputs results

◆ cookie()

uint64_t cryptonote::tx_memory_pool::cookie ( ) const

inline

return the cookie

Returns: the cookie

◆ deinit()

bool cryptonote::tx_memory_pool::deinit ( )

attempts to save the transaction pool state to disk

Currently fails (returns false) if the data directory from init() does not exist and cannot be created, but returns true even if saving to disk is unsuccessful.

Returns: true in most cases (see above)

◆ fill_block_template()

bool cryptonote::tx_memory_pool::fill_block_template	(	block &	bl,
		size_t	median_weight,
		uint64_t	already_generated_coins,
		size_t &	total_weight,
		uint64_t &	fee,
		uint64_t &	expected_reward,
		uint8_t	version )

Chooses transactions for a block to include.

Parameters

bl	return-by-reference the block to fill in with transactions
median_weight	the current median block weight
already_generated_coins	the current total number of coins "minted"
total_weight	return-by-reference the total weight of the new block
fee	return-by-reference the total of fees from the included transactions
expected_reward	return-by-reference the total reward awarded to the miner finding this block, including transaction fees
version	hard fork version to use for consensus rules

Returns: true

◆ find_tx_in_sorted_container()

sorted_tx_container::iterator cryptonote::tx_memory_pool::find_tx_in_sorted_container ( const crypto::hash & id ) const

private

get an iterator to a transaction in the sorted container

Parameters

id	the hash of the transaction to look for

Returns: an iterator, possibly to the end of the container if not found

◆ get_block_template_backlog()

void cryptonote::tx_memory_pool::get_block_template_backlog	(	std::vector< tx_block_template_backlog_entry > &	backlog,
		bool	include_sensitive = false ) const

get (hash, weight, fee) for transactions in the pool - the minimum required information to create a block template

Not all transactions in the pool will be returned for performance reasons If there are too many transactions in the pool, only the highest-paying transactions will be returned - but enough for the miner to create a full block

Parameters

backlog	return-by-reference that data
include_sensitive	return stempool, anonymity-pool, and unrelayed txes

◆ get_complement()

bool cryptonote::tx_memory_pool::get_complement	(	const std::vector< crypto::hash > &	hashes,
		std::vector< cryptonote::blobdata > &	txes ) const

get transactions not in the passed set

◆ get_pool_for_rpc()

bool cryptonote::tx_memory_pool::get_pool_for_rpc	(	std::vector< cryptonote::rpc::tx_in_pool > &	tx_infos,
		cryptonote::rpc::key_images_with_tx_hashes &	key_image_infos ) const

get information about all transactions and key images in the pool

see documentation on tx_in_pool and key_images_with_tx_hashes for more details

Parameters

tx_infos	[out] the transactions' information
key_image_infos	[out] the spent key images' information

Returns: true

◆ get_pool_info()

bool cryptonote::tx_memory_pool::get_pool_info	(	time_t	start_time,
		bool	include_sensitive,
		size_t	max_tx_count,
		std::vector< std::pair< crypto::hash, tx_details > > &	added_txs,
		std::vector< crypto::hash > &	remaining_added_txids,
		std::vector< crypto::hash > &	removed_txs,
		bool &	incremental ) const

get info necessary for update of pool-related info in a wallet, preferably incremental

Returns: true on success, false on error

◆ get_relayable_transactions()

bool cryptonote::tx_memory_pool::get_relayable_transactions ( std::vector< std::tuple< crypto::hash, cryptonote::blobdata, relay_method > > & txs )

get a list of all relayable transactions and their hashes

"relayable" in this case means: nonzero fee hasn't been relayed too recently isn't old enough that relaying it is considered harmful Note a transaction can be "relayable" even if do_not_relay is true

This function will skip all DB checks if an insufficient amount of time since the last call.

Parameters

txs	return-by-reference the transactions and their hashes

Returns: True if DB was checked, false if DB checks skipped.

◆ get_transaction()

bool cryptonote::tx_memory_pool::get_transaction	(	const crypto::hash &	h,
		cryptonote::blobdata &	txblob,
		relay_category	tx_category ) const

get a specific transaction from the pool

Parameters

h	the hash of the transaction to get
tx	return-by-reference the transaction blob requested
tx_relay	last relay method us

Returns: true if the transaction is found, otherwise false

◆ get_transaction_backlog()

void cryptonote::tx_memory_pool::get_transaction_backlog	(	std::vector< tx_backlog_entry > &	backlog,
		bool	include_sensitive = false ) const

get (weight, fee, receive time) for all transaction in the pool

Parameters

txs	return-by-reference that data
include_sensitive	return stempool, anonymity-pool, and unrelayed txes

◆ get_transaction_hashes()

void cryptonote::tx_memory_pool::get_transaction_hashes	(	std::vector< crypto::hash > &	txs,
		bool	include_sensitive = false ) const

get a list of all transaction hashes in the pool

Parameters

txs	return-by-reference the list of transactions
include_sensitive	return stempool, anonymity-pool, and unrelayed txes

◆ get_transaction_info()

bool cryptonote::tx_memory_pool::get_transaction_info	(	const crypto::hash &	txid,
		tx_details &	td,
		bool	include_sensitive_data,
		bool	include_blob = false ) const

get infornation about a single transaction

◆ get_transaction_stats()

void cryptonote::tx_memory_pool::get_transaction_stats	(	struct txpool_stats &	stats,
		bool	include_sensitive = false ) const

get a summary statistics of all transaction hashes in the pool

Parameters

stats	return-by-reference the pool statistics
include_sensitive	return stempool, anonymity-pool, and unrelayed txes

◆ get_transactions()

void cryptonote::tx_memory_pool::get_transactions	(	std::vector< transaction > &	txs,
		bool	include_sensitive = false ) const

get a list of all transactions in the pool

Parameters

txs	return-by-reference the list of transactions
include_sensitive	return stempool, anonymity-pool, and unrelayed txes

◆ get_transactions_and_spent_keys_info()

bool cryptonote::tx_memory_pool::get_transactions_and_spent_keys_info	(	std::vector< tx_info > &	tx_infos,
		std::vector< spent_key_image_info > &	key_image_infos,
		bool	include_sensitive_data = false ) const

get information about all transactions and key images in the pool

see documentation on tx_info and spent_key_image_info for more details

Parameters

tx_infos	return-by-reference the transactions' information
key_image_infos	return-by-reference the spent key images' information
include_sensitive_data	return stempool, anonymity-pool, and unrelayed txes and fields that are sensitive to the node privacy

Returns: true

◆ get_transactions_count()

size_t cryptonote::tx_memory_pool::get_transactions_count ( bool include_sensitive = false ) const

get the total number of transactions in the pool

Returns: the number of transactions in the pool

◆ get_transactions_info()

bool cryptonote::tx_memory_pool::get_transactions_info	(	const std::vector< crypto::hash > &	txids,
		std::vector< std::pair< crypto::hash, tx_details > > &	txs,
		bool	include_sensitive_data = false ) const

get information about multiple transactions

◆ get_txpool_weight()

size_t cryptonote::tx_memory_pool::get_txpool_weight ( ) const

get the cumulative txpool weight in bytes

Returns: the cumulative txpool weight in bytes

◆ have_key_images()

bool cryptonote::tx_memory_pool::have_key_images	(	const std::unordered_set< crypto::key_image > &	kic,
		const transaction_prefix &	tx )

staticprivate

check if any of a transaction's spent key images are present in a given set

Parameters

kic	the set of key images to check against
tx	the transaction to check

Returns: true if any key images present in the set, otherwise false

◆ have_tx()

bool cryptonote::tx_memory_pool::have_tx	(	const crypto::hash &	id,
		relay_category	tx_category ) const

checks if the pool has a transaction with the given hash

Parameters

id	the hash to look for
tx_category	a filter for txes

Returns: true if the transaction is in the pool and meets tx_category requirements

◆ have_tx_keyimg_as_spent()

bool cryptonote::tx_memory_pool::have_tx_keyimg_as_spent	(	const crypto::key_image &	key_im,
		const crypto::hash &	txid ) const

private

check if a transaction in the pool has a given spent key image

Parameters

key_im	the spent key image to look for
txid	hash of the new transaction where key_im was seen.

Returns: true if the spent key image is present, otherwise false

◆ have_tx_keyimges_as_spent()

bool cryptonote::tx_memory_pool::have_tx_keyimges_as_spent	(	const transaction &	tx,
		const crypto::hash &	txid ) const

private

check if any spent key image in a transaction is in the pool

Checks if any of the spent key images in a given transaction are present in any of the transactions in the transaction pool.

Note: see tx_pool::have_tx_keyimg_as_spent

Parameters

tx	the transaction to check spent key images of
txid	hash of tx.

Returns: true if any spent key images are present in the pool, otherwise false

◆ init()

bool cryptonote::tx_memory_pool::init	(	size_t	max_txpool_weight = 0,
		bool	mine_stem_txes = false )

loads pool state (if any) from disk, and initializes pool

Parameters

max_txpool_weight	the max weight in bytes
mine_stem_txes	whether to mine txes in stem relay mode

Returns: true

◆ insert_key_images()

bool cryptonote::tx_memory_pool::insert_key_images	(	const transaction_prefix &	tx,
		const crypto::hash &	txid,
		relay_method	tx_relay )

private

insert key images into m_spent_key_images

Returns: true on success, false on error

◆ is_transaction_ready_to_go() [1/2]

bool cryptonote::tx_memory_pool::is_transaction_ready_to_go	(	txpool_tx_meta_t &	txd,
		const crypto::hash &	txid,
		const cryptonote::blobdata &	txblob,
		transaction &	tx ) const

private

◆ is_transaction_ready_to_go() [2/2]

bool cryptonote::tx_memory_pool::is_transaction_ready_to_go	(	txpool_tx_meta_t &	txd,
		const crypto::hash &	txid,
		const cryptonote::blobdata_ref &	txblob,
		transaction &	tx ) const

private

check if a transaction is a valid candidate for inclusion in a block

Parameters

txd	the transaction to check (and info about it)
txid	the txid of the transaction to check
txblob	the transaction blob to check
tx	the parsed transaction, if successful

Returns: true if the transaction is good to go, otherwise false

◆ lock()

void cryptonote::tx_memory_pool::lock ( ) const

locks the transaction pool

◆ mark_double_spend()

void cryptonote::tx_memory_pool::mark_double_spend ( const transaction & tx )

private

mark all transactions double spending the one passed

◆ on_blockchain_dec()

bool cryptonote::tx_memory_pool::on_blockchain_dec	(	uint64_t	new_block_height,
		const crypto::hash &	top_block_id )

action to take when notified of a block removed from the blockchain

Currently does nothing

Parameters

new_block_height	the height of the blockchain after the change
top_block_id	the hash of the new top block

Returns: true

◆ on_blockchain_inc()

bool cryptonote::tx_memory_pool::on_blockchain_inc	(	uint64_t	new_block_height,
		const crypto::hash &	top_block_id )

action to take when notified of a block added to the blockchain

Currently does nothing

Parameters

new_block_height	the height of the blockchain after the change
top_block_id	the hash of the new top block

Returns: true

◆ on_idle()

void cryptonote::tx_memory_pool::on_idle ( )

action to take periodically

Currently checks transaction pool for stale ("stuck") transactions

◆ print_pool()

std::string cryptonote::tx_memory_pool::print_pool ( bool short_format ) const

get a string containing human-readable pool information

Parameters

short_format whether to use a shortened format for the info

Returns: the string

◆ prune()

void cryptonote::tx_memory_pool::prune ( size_t bytes = 0 )

private

prune lowest fee/byte txes till we're not above bytes

if bytes is 0, use m_txpool_max_weight

◆ reduce_txpool_weight()

void cryptonote::tx_memory_pool::reduce_txpool_weight ( size_t weight )

reduce the cumulative txpool weight by the weight provided

Parameters

weight the weight to reduce the total txpool weight by

◆ remove_stuck_transactions()

bool cryptonote::tx_memory_pool::remove_stuck_transactions ( )

private

remove old transactions from the pool

After a certain time, it is assumed that a transaction which has not yet been mined will likely not be mined. These transactions are removed from the pool to avoid buildup.

Returns: true

◆ remove_transaction_keyimages()

bool cryptonote::tx_memory_pool::remove_transaction_keyimages	(	const transaction_prefix &	tx,
		const crypto::hash &	txid )

private

forget a transaction's spent key images

Spent key images are stored separately from transactions for convenience/speed, so this is part of the process of removing a transaction from the pool.

Parameters

tx	the transaction
txid	the transaction's hash

Returns: false if any key images to be removed cannot be found, otherwise true

◆ remove_tx_from_transient_lists()

void cryptonote::tx_memory_pool::remove_tx_from_transient_lists	(	const cryptonote::sorted_tx_container::iterator &	sorted_it,
		const crypto::hash &	txid,
		bool	sensitive )

private

◆ set_relayed()

void cryptonote::tx_memory_pool::set_relayed	(	epee::span< const crypto::hash >	hashes,
		relay_method	tx_relay,
		std::vector< bool > &	just_broadcasted )

tell the pool that certain transactions were just relayed

Parameters

hashes	list of tx hashes that are about to be relayed
tx_relay	update how the tx left this node
just_broadcasted	true if a tx was just broadcasted

◆ set_txpool_max_weight()

void cryptonote::tx_memory_pool::set_txpool_max_weight ( size_t bytes )

set the max cumulative txpool weight in bytes

Parameters

bytes the max cumulative txpool weight in bytes

◆ take_tx()

bool cryptonote::tx_memory_pool::take_tx	(	const crypto::hash &	id,
		transaction &	tx,
		cryptonote::blobdata &	txblob,
		size_t &	tx_weight,
		uint64_t &	fee,
		bool &	relayed,
		bool &	do_not_relay,
		bool &	double_spend_seen,
		bool &	pruned,
		bool	suppress_missing_msgs = false )

takes a transaction with the given hash from the pool

Parameters

id	the hash of the transaction
tx	return-by-reference the transaction taken
txblob	return-by-reference the transaction as a blob
tx_weight	return-by-reference the transaction's weight
fee	the transaction fee
relayed	return-by-reference was transaction relayed to us by the network?
do_not_relay	return-by-reference is transaction not to be relayed to the network?
double_spend_seen	return-by-reference was a double spend seen for that transaction?
pruned	return-by-reference is the tx pruned
suppress_missing_msgs	suppress warning msgs when txid is missing (optional, defaults to false)

Returns: true unless the transaction cannot be found in the pool

◆ track_removed_tx()

void cryptonote::tx_memory_pool::track_removed_tx	(	const crypto::hash &	txid,
		bool	sensitive )

private

◆ unlock()

void cryptonote::tx_memory_pool::unlock ( ) const

unlocks the transaction pool

◆ validate()

size_t cryptonote::tx_memory_pool::validate ( uint8_t version )

remove transactions from the pool which are no longer valid

With new versions of the currency, what conditions render a transaction invalid may change. This function clears those which were received before a version change and no longer conform to requirements.

Parameters

version the version the transactions must conform to

Returns: the number of transactions removed

Member Data Documentation

◆ m_added_txs_by_id

std::unordered_map<crypto::hash, time_t> cryptonote::tx_memory_pool::m_added_txs_by_id

private

◆ m_added_txs_start_time

time_t cryptonote::tx_memory_pool::m_added_txs_start_time

private

◆ m_blockchain

Blockchain& cryptonote::tx_memory_pool::m_blockchain

private

reference to the Blockchain object

◆ m_cookie

std::atomic<uint64_t> cryptonote::tx_memory_pool::m_cookie

private

incremented at each change

◆ m_input_cache

std::unordered_map<crypto::hash, std::tuple<bool, tx_verification_context, uint64_t, crypto::hash> > cryptonote::tx_memory_pool::m_input_cache

mutableprivate

◆ m_mine_stem_txes

bool cryptonote::tx_memory_pool::m_mine_stem_txes

private

◆ m_next_check

std::atomic<time_t> cryptonote::tx_memory_pool::m_next_check

private

Next timestamp that a DB check for relayable txes is allowed.

◆ m_parsed_tx_cache

std::unordered_map<crypto::hash, transaction> cryptonote::tx_memory_pool::m_parsed_tx_cache

private

◆ m_remove_stuck_tx_interval

epee::math_helper::once_a_time_seconds<30> cryptonote::tx_memory_pool::m_remove_stuck_tx_interval

private

interval on which to check for stale/"stuck" transactions

◆ m_removed_txs_by_time

std::multimap<time_t, removed_tx_info> cryptonote::tx_memory_pool::m_removed_txs_by_time

private

◆ m_removed_txs_start_time

time_t cryptonote::tx_memory_pool::m_removed_txs_start_time

private

◆ m_spent_key_images

key_images_container cryptonote::tx_memory_pool::m_spent_key_images

private

container for spent key images from the transactions in the pool

◆ m_timed_out_transactions

std::unordered_set<crypto::hash> cryptonote::tx_memory_pool::m_timed_out_transactions

private

transactions which are unlikely to be included in blocks

These transactions are kept in RAM in case they are included in a block eventually, but this container is not saved to disk.

◆ m_transactions_lock

epee::critical_section cryptonote::tx_memory_pool::m_transactions_lock

mutableprivate

lock for the pool

◆ m_txpool_max_weight

size_t cryptonote::tx_memory_pool::m_txpool_max_weight

private

◆ m_txpool_weight

size_t cryptonote::tx_memory_pool::m_txpool_weight

private

◆ m_txs_by_fee_and_receive_time

sorted_tx_container cryptonote::tx_memory_pool::m_txs_by_fee_and_receive_time

private

< container for transactions organized by fee per size and receive time

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

src/cryptonote_core/tx_pool.h
src/cryptonote_core/tx_pool.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ key_images_container

Constructor & Destructor Documentation

◆ tx_memory_pool()

Member Function Documentation

◆ add_tx() [1/2]

◆ add_tx() [2/2]

◆ add_tx_to_transient_lists()

◆ append_key_images()

◆ check_for_key_images()

◆ check_tx_inputs()

◆ cookie()

◆ deinit()

◆ fill_block_template()

◆ find_tx_in_sorted_container()

◆ get_block_template_backlog()

◆ get_complement()

◆ get_pool_for_rpc()

◆ get_pool_info()

◆ get_relayable_transactions()

◆ get_transaction()

◆ get_transaction_backlog()

◆ get_transaction_hashes()

◆ get_transaction_info()

◆ get_transaction_stats()

◆ get_transactions()

◆ get_transactions_and_spent_keys_info()

◆ get_transactions_count()

◆ get_transactions_info()

◆ get_txpool_weight()

◆ have_key_images()

◆ have_tx()

◆ have_tx_keyimg_as_spent()

◆ have_tx_keyimges_as_spent()

◆ init()

◆ insert_key_images()

◆ is_transaction_ready_to_go() [1/2]

◆ is_transaction_ready_to_go() [2/2]

◆ lock()

◆ mark_double_spend()

◆ on_blockchain_dec()

◆ on_blockchain_inc()

◆ on_idle()

◆ print_pool()

◆ prune()

◆ reduce_txpool_weight()

◆ remove_stuck_transactions()

◆ remove_transaction_keyimages()

◆ remove_tx_from_transient_lists()

◆ set_relayed()

◆ set_txpool_max_weight()

◆ take_tx()

◆ track_removed_tx()

◆ unlock()

◆ validate()

Member Data Documentation

◆ m_added_txs_by_id

◆ m_added_txs_start_time

◆ m_blockchain

◆ m_cookie

◆ m_input_cache

◆ m_mine_stem_txes

◆ m_next_check

◆ m_parsed_tx_cache

◆ m_remove_stuck_tx_interval

◆ m_removed_txs_by_time

◆ m_removed_txs_start_time

◆ m_spent_key_images

◆ m_timed_out_transactions

◆ m_transactions_lock

◆ m_txpool_max_weight

◆ m_txpool_weight

◆ m_txs_by_fee_and_receive_time