cryptonote::tx_memory_pool Class Reference

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...

Public Member Functions
	tx_memory_pool (Blockchain &bchs)
	Constructor. More...
bool	add_tx (transaction &tx, const crypto::hash &id, const cryptonote::blobdata &blob, size_t tx_weight, tx_verification_context &tvc, bool kept_by_block, bool relayed, bool do_not_relay, uint8_t version)
bool	add_tx (transaction &tx, tx_verification_context &tvc, bool kept_by_block, bool relayed, bool do_not_relay, uint8_t version)
	add a transaction to the transaction pool More...
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 &nonexistent_utxo_seen)
	takes a transaction with the given hash from the pool More...
bool	have_tx (const crypto::hash &id) const
	checks if the pool has a transaction with the given hash More...
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 More...
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 More...
void	on_idle ()
	action to take periodically More...
void	lock () const
	locks the transaction pool More...
void	unlock () const
	unlocks the transaction pool More...
bool	init (size_t max_txpool_weight=0)
	loads pool state (if any) from disk, and initializes pool More...
bool	deinit ()
	attempts to save the transaction pool state to disk More...
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. More...
void	get_transactions (std::vector< transaction > &txs, bool include_unrelayed_txes=true) const
	get a list of all transactions in the pool More...
void	get_transaction_hashes (std::vector< crypto::hash > &txs, bool include_unrelayed_txes=true) const
	get a list of all transaction hashes in the pool More...
void	get_transaction_backlog (std::vector< tx_backlog_entry > &backlog, bool include_unrelayed_txes=true) const
	get (weight, fee, receive time) for all transaction in the pool More...
void	get_transaction_stats (struct txpool_stats &stats, bool include_unrelayed_txes=true) const
	get a summary statistics of all transaction hashes in the pool More...
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=true) const
	get information about all transactions and key images in the pool More...
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 More...
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 More...
bool	get_transaction (const crypto::hash &h, cryptonote::blobdata &txblob) const
	get a specific transaction from the pool More...
bool	get_relayable_transactions (std::vector< std::pair< crypto::hash, cryptonote::blobdata >> &txs) const
	get a list of all relayable transactions and their hashes More...
void	set_relayed (const std::vector< std::pair< crypto::hash, cryptonote::blobdata >> &txs)
	tell the pool that certain transactions were just relayed More...
size_t	get_transactions_count (bool include_unrelayed_txes=true) const
	get the total number of transactions in the pool More...
std::string	print_pool (bool short_format) const
	get a string containing human-readable pool information More...
size_t	validate (uint8_t version)
	remove transactions from the pool which are no longer valid More...
uint64_t	cookie () const
	return the cookie More...
size_t	get_txpool_weight () const
	get the cumulative txpool weight in bytes More...
void	set_txpool_max_weight (size_t bytes)
	set the max cumulative txpool weight in bytes More...

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

Definition at line 94 of file tx_pool.h.

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

Definition at line 115 of file tx_pool.cpp.

                                                : m_blockchain(bchs), m_txpool_max_weight(DEFAULT_TXPOOL_MAX_WEIGHT), m_txpool_weight(0), m_cookie(0)
  {
 
  }

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,
		bool	kept_by_block,
		bool	relayed,
		bool	do_not_relay,
		uint8_t	version
	)

Parameters

id	the transaction's hash
tx_weight	the transaction's weight

Definition at line 120 of file tx_pool.cpp.

  {
    // this should already be called with that lock, but let's make it explicit for clarity
    CRITICAL_REGION_LOCAL(m_transactions_lock);
 
    PERF_TIMER(add_tx);
    if (tx.version == 0)
    {
      // v0 never accepted
      LOG_PRINT_L1("transaction version 0 is invalid");
      tvc.m_verification_failed = true;
      return false;
    }
 
    // we do not accept transactions that timed out before, unless they're
    // kept_by_block
    if (!kept_by_block && m_timed_out_transactions.find(id) != m_timed_out_transactions.end())
    {
      // not clear if we should set that, since verifivation (sic) did not fail before, since
      // the tx was accepted before timing out.
      tvc.m_verification_failed = true;
      return false;
    }
 
    if(!check_inputs_types_supported(tx))
    {
      tvc.m_verification_failed = true;
      tvc.m_invalid_input = true;
      return false;
    }
 
    if(!check_outs_valid(tx))
    {
      tvc.m_verification_failed = true;
      tvc.m_invalid_output = true;
      return false;
    }
 
    // fee per kilobyte, size rounded up.
    uint64_t fee = 0;
 
    uint64_t inputs_amount = 0;
    if(!get_inputs_etn_amount(tx, inputs_amount))
    {
      tvc.m_verification_failed = true;
      return false;
    }
 
    uint64_t outputs_amount = get_outs_etn_amount(tx);
    if(outputs_amount > inputs_amount)
    {
      LOG_PRINT_L1("transaction use more ETN than it has: use " << print_etn(outputs_amount) << ", have " << print_etn(inputs_amount));
      tvc.m_verification_failed = true;
      tvc.m_overspend = true;
      return false;
    }
    else if(tx.version != 2 && outputs_amount == inputs_amount)
    {
      LOG_PRINT_L1("transaction fee is zero: outputs_amount == inputs_amount, rejecting.");
      tvc.m_verification_failed = true;
      tvc.m_fee_too_low = true;
      return false;
    }
 
    fee = inputs_amount - outputs_amount;
 
    if(tx.version == 2 && fee != 0) //Assure 0 fee tx v2 (migration tx)
    {
      LOG_PRINT_L1("transaction v2 fee is greater than zero, rejecting.");
      tvc.m_verification_failed = true;
      return false;
    }
 
    if (tx.version != 2 && !kept_by_block && !m_blockchain.check_fee(tx_weight, fee))
    {
      tvc.m_verification_failed = true;
      tvc.m_fee_too_low = true;
      return false;
    }
 
    size_t tx_weight_limit = get_transaction_weight_limit(version);
    if ((!kept_by_block || version >= HF_VERSION_PER_BYTE_FEE) && tx_weight > tx_weight_limit)
    {
      LOG_PRINT_L1("transaction is too heavy: " << tx_weight << " bytes, maximum weight: " << tx_weight_limit);
      tvc.m_verification_failed = true;
      tvc.m_too_big = true;
      return false;
    }
 
    // if the transaction came from a block popped from the chain,
    // don't check if we have its key images as spent.
    // TODO: Investigate why not?
    if(!kept_by_block)
    {
        if(tx.version <= 2) {
            if (key_images_already_spent(tx)) {
                mark_double_spend_or_nonexistent_utxo(tx);
                LOG_PRINT_L1("Transaction with id= " << id << " used already spent key images");
                tvc.m_verification_failed = true;
                tvc.m_double_spend = true;
                return false;
            }
        }
      if(tx.version > 2) {
          if (utxo_nonexistent(tx)) {
              mark_double_spend_or_nonexistent_utxo(tx);
              LOG_PRINT_L1("Transaction with id= " << id << " used nonexistent utxos");
              tvc.m_verification_failed = true;
              tvc.m_utxo_nonexistent = true;
              return false;
          }
      }
    }
 
    if (!m_blockchain.check_tx_outputs(tx, tvc))
    {
      LOG_PRINT_L1("Transaction with id= "<< id << " has at least one invalid output");
      tvc.m_verification_failed = true;
      tvc.m_invalid_output = true;
      return false;
    }
 
    // assume failure during verification steps until success is certain
    tvc.m_verification_failed = true;
 
    time_t receive_time = time(nullptr);
 
    crypto::hash max_used_block_id = null_hash;
    uint64_t max_used_block_height = 0;
    cryptonote::txpool_tx_meta_t meta;
    bool ch_inp_res = check_tx_inputs([&tx]()->cryptonote::transaction&{ return tx; }, id, max_used_block_height, max_used_block_id, tvc, kept_by_block);
    if(!ch_inp_res)
    {
      // if the transaction was valid before (kept_by_block), then it
      // may become valid again, so ignore the failed inputs check.
      if(kept_by_block)
      {
        meta.weight = tx_weight;
        meta.fee = fee;
        meta.max_used_block_id = null_hash;
        meta.max_used_block_height = 0;
        meta.last_failed_height = 0;
        meta.last_failed_id = null_hash;
        meta.kept_by_block = kept_by_block;
        meta.receive_time = receive_time;
        meta.last_relayed_time = time(NULL);
        meta.relayed = relayed;
        meta.do_not_relay = do_not_relay;
        meta.double_spend_seen = key_images_already_spent(tx);
        meta.utxo_nonexistent_seen = utxo_nonexistent(tx);
        meta.bf_padding = 0;
        memset(meta.padding, 0, sizeof(meta.padding));
        try
        {
          if (kept_by_block)
            m_parsed_tx_cache.insert(std::make_pair(id, tx));
          CRITICAL_REGION_LOCAL1(m_blockchain);
          LockedTXN lock(m_blockchain);
          m_blockchain.add_txpool_tx(id, blob, meta);
          if ((tx.version <= 2 && !insert_key_images(tx, id, kept_by_block)) || (tx.version >= 3 && !insert_utxos(tx, id, kept_by_block)))
            return false;
          m_txs_by_fee_and_receive_time.emplace(std::pair<double, std::time_t>(fee / (double)tx_weight, receive_time), id);
          lock.commit();
        }
        catch (const std::exception &e)
        {
          MERROR("transaction already exists at inserting in memory pool: " << e.what());
          return false;
        }
        tvc.m_verification_impossible = true;
        tvc.m_added_to_pool = true;
      }else
      {
        LOG_PRINT_L1("tx used wrong inputs, rejected");
        tvc.m_verification_failed = true;
        tvc.m_invalid_input = true;
        return false;
      }
    }else
    {
      //update transactions container
      meta.weight = tx_weight;
      meta.kept_by_block = kept_by_block;
      meta.fee = fee;
      meta.max_used_block_id = max_used_block_id;
      meta.max_used_block_height = max_used_block_height;
      meta.last_failed_height = 0;
      meta.last_failed_id = null_hash;
      meta.receive_time = receive_time;
      meta.last_relayed_time = time(NULL);
      meta.relayed = relayed;
      meta.do_not_relay = do_not_relay;
      meta.double_spend_seen = false;
      meta.utxo_nonexistent_seen = false;
      meta.bf_padding = 0;
      memset(meta.padding, 0, sizeof(meta.padding));
 
      try
      {
        if (kept_by_block)
          m_parsed_tx_cache.insert(std::make_pair(id, tx));
        CRITICAL_REGION_LOCAL1(m_blockchain);
        LockedTXN lock(m_blockchain);
        m_blockchain.remove_txpool_tx(id);
        m_blockchain.add_txpool_tx(id, blob, meta);
        if ((tx.version <= 2 && !insert_key_images(tx, id, kept_by_block)) || (tx.version >= 3 && !insert_utxos(tx, id, kept_by_block)))
          return false;
        m_txs_by_fee_and_receive_time.emplace(std::pair<double, std::time_t>(fee / (double)tx_weight, receive_time), id);
        lock.commit();
      }
      catch (const std::exception &e)
      {
        MERROR("internal error: transaction already exists at inserting in memory pool: " << e.what());
        return false;
      }
      tvc.m_added_to_pool = true;
 
      if(!do_not_relay)
        tvc.m_should_be_relayed = true;
    }
 
    tvc.m_verification_failed = false;
    m_txpool_weight += tx_weight;
 
    ++m_cookie;
 
    MINFO("Transaction added to pool: txid " << id << " weight: " << tx_weight << " fee/byte: " << (fee / (double)tx_weight));
 
    prune(m_txpool_max_weight);
 
    return true;
  }

Here is the call graph for this function:

add_tx() [2/2]

bool cryptonote::tx_memory_pool::add_tx	(	transaction &	tx,
		tx_verification_context &	tvc,
		bool	kept_by_block,
		bool	relayed,
		bool	do_not_relay,
		uint8_t	version
	)

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
kept_by_block	has this transaction been in a block?
relayed	was this transaction from the network or a local client?
do_not_relay	to avoid relaying the transaction to the network
version	the version used to create the transaction

Returns

true if the transaction passes validations, otherwise false

Definition at line 353 of file tx_pool.cpp.

  {
    crypto::hash h = null_hash;
    size_t blob_size = 0;
    cryptonote::blobdata bl;
    t_serializable_object_to_blob(tx, bl);
    if (bl.size() == 0 || !get_transaction_hash(tx, h))
      return false;
    return add_tx(tx, h, bl, get_transaction_weight(tx, bl.size()), tvc, keeped_by_block, relayed, do_not_relay, version);
  }

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

Definition at line 980 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
 
    spent.clear();
 
    for (const auto& image : key_images)
    {
      spent.push_back(m_spent_key_images.find(image) == m_spent_key_images.end() ? false : true);
    }
 
    return true;
  }

Here is the caller graph for this function:

cookie()

uint64_t cryptonote::tx_memory_pool::cookie ( ) const

inline

return the cookie

Returns

the cookie

Definition at line 373 of file tx_pool.h.

{ return m_cookie; }

Here is the caller graph for this function:

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)

Definition at line 1623 of file tx_pool.cpp.

  {
    return true;
  }

Here is the caller graph for this function:

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

Definition at line 1358 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
 
    uint64_t best_coinbase = 0, coinbase = 0;
    total_weight = 0;
    fee = 0;
    
    //baseline empty block
    get_block_reward(median_weight, total_weight, already_generated_coins, best_coinbase, version, m_blockchain.get_current_blockchain_height(), m_blockchain.get_nettype());
 
 
    size_t max_total_weight_pre_v5 = (130 * median_weight) / 100 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
    size_t max_total_weight_v5 = 2 * median_weight - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
    size_t max_total_weight = version >= 5 ? max_total_weight_v5 : max_total_weight_pre_v5;
    std::unordered_set<crypto::key_image> k_images;
    std::unordered_set<std::string> utxos;
 
    LOG_PRINT_L2("Filling block template, median weight " << median_weight << ", " << m_txs_by_fee_and_receive_time.size() << " txes in the pool");
 
    LockedTXN lock(m_blockchain);
 
    auto sorted_it = m_txs_by_fee_and_receive_time.begin();
    for (; sorted_it != m_txs_by_fee_and_receive_time.end(); ++sorted_it)
    {
      txpool_tx_meta_t meta;
      if (!m_blockchain.get_txpool_tx_meta(sorted_it->second, meta))
      {
        MERROR("  failed to find tx meta");
        continue;
      }
      LOG_PRINT_L2("Considering " << sorted_it->second << ", weight " << meta.weight << ", current block weight " << total_weight << "/" << max_total_weight << ", current coinbase " << print_etn(best_coinbase));
 
      // Can not exceed maximum block weight
      if (max_total_weight < total_weight + meta.weight)
      {
        LOG_PRINT_L2("  would exceed maximum block weight");
        continue;
      }
 
      // start using the optimal filling algorithm from v5
      if (version >= 5)
      {
        // If we're getting lower coinbase tx,
        // stop including more tx
        uint64_t block_reward;
        if(!get_block_reward(median_weight, total_weight + meta.weight, already_generated_coins, block_reward, version, m_blockchain.get_current_blockchain_height(), m_blockchain.get_nettype()))
        {
          LOG_PRINT_L2("  would exceed maximum block weight");
          continue;
        }
        coinbase = block_reward + fee + meta.fee;
        if (coinbase < template_accept_threshold(best_coinbase))
        {
          LOG_PRINT_L2("  would decrease coinbase to " << print_etn(coinbase));
          continue;
        }
      }
      else
      {
        // If we've exceeded the penalty free weight,
        // stop including more tx
        if (total_weight > median_weight)
        {
          LOG_PRINT_L2("  would exceed median block weight");
          break;
        }
      }
 
      cryptonote::blobdata txblob = m_blockchain.get_txpool_tx_blob(sorted_it->second);
      cryptonote::transaction tx;
 
      // Skip transactions that are not ready to be
      // included into the blockchain or that are
      // missing key images
      const cryptonote::txpool_tx_meta_t original_meta = meta;
      bool ready = false;
      try
      {
        ready = is_transaction_ready_to_go(meta, sorted_it->second, txblob, tx);
      }
      catch (const std::exception &e)
      {
        MERROR("Failed to check transaction readiness: " << e.what());
        // continue, not fatal
      }
      if (memcmp(&original_meta, &meta, sizeof(meta)))
      {
        try
    {
      m_blockchain.update_txpool_tx(sorted_it->second, meta);
    }
        catch (const std::exception &e)
    {
      MERROR("Failed to update tx meta: " << e.what());
      // continue, not fatal
    }
      }
      if (!ready)
      {
        LOG_PRINT_L2("  not ready to go");
        continue;
      }
      if (have_key_images(k_images, tx))
      {
        LOG_PRINT_L2("  key images already seen");
        continue;
      }
      if (have_utxos(utxos, tx))
      {
        LOG_PRINT_L2("  utxos already seen");
        continue;
      }
 
      bl.tx_hashes.push_back(sorted_it->second);
      total_weight += meta.weight;
      fee += meta.fee;
      best_coinbase = coinbase;
      append_key_images(k_images, tx);
      append_utxos(utxos, tx);
      LOG_PRINT_L2("  added, new block weight " << total_weight << "/" << max_total_weight << ", coinbase " << print_etn(best_coinbase));
    }
    lock.commit();
 
    expected_reward = best_coinbase;
    LOG_PRINT_L2("Block template filled with " << bl.tx_hashes.size() << " txes, weight "
        << total_weight << "/" << max_total_weight << ", coinbase " << print_etn(best_coinbase)
        << " (including " << print_etn(fee) << " in fees)");
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 931 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    tx_infos.reserve(m_blockchain.get_txpool_tx_count());
    key_image_infos.reserve(m_blockchain.get_txpool_tx_count());
    m_blockchain.for_all_txpool_txes([&tx_infos, key_image_infos](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
      cryptonote::rpc::tx_in_pool txi;
      txi.tx_hash = txid;
      if (!parse_and_validate_tx_from_blob(*bd, txi.tx))
      {
        MERROR("Failed to parse tx from txpool");
        // continue
        return true;
      }
      txi.tx.set_hash(txid);
      txi.blob_size = bd->size();
      txi.weight = meta.weight;
      txi.fee = meta.fee;
      txi.kept_by_block = meta.kept_by_block;
      txi.max_used_block_height = meta.max_used_block_height;
      txi.max_used_block_hash = meta.max_used_block_id;
      txi.last_failed_block_height = meta.last_failed_height;
      txi.last_failed_block_hash = meta.last_failed_id;
      txi.receive_time = meta.receive_time;
      txi.relayed = meta.relayed;
      txi.last_relayed_time = meta.last_relayed_time;
      txi.do_not_relay = meta.do_not_relay;
      txi.double_spend_seen = meta.double_spend_seen;
      txi.nonexistent_utxo_seen = meta.utxo_nonexistent_seen;
 
      tx_infos.push_back(txi);
      return true;
    }, true, false);
 
    for (const key_images_container::value_type& kee : m_spent_key_images) {
      std::vector<crypto::hash> tx_hashes;
      const std::unordered_set<crypto::hash>& kei_image_set = kee.second;
      for (const crypto::hash& tx_id_hash : kei_image_set)
      {
        tx_hashes.push_back(tx_id_hash);
      }
 
      const crypto::key_image& k_image = kee.first;
      key_image_infos[k_image] = std::move(tx_hashes);
    }
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_relayable_transactions()

bool cryptonote::tx_memory_pool::get_relayable_transactions

(

std::vector< std::pair< crypto::hash, cryptonote::blobdata >> &

txs

)

const

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

Parameters

txs	return-by-reference the transactions and their hashes

Returns

true

Definition at line 665 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    const uint64_t now = time(NULL);
    txs.reserve(m_blockchain.get_txpool_tx_count());
    m_blockchain.for_all_txpool_txes([this, now, &txs](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *){
      // 0 fee transactions are never relayed
      if(!meta.do_not_relay && now - meta.last_relayed_time > get_relay_delay(now, meta.receive_time))
      {
        // if the tx is older than half the max lifetime, we don't re-relay it, to avoid a problem
        // mentioned by smooth where nodes would flush txes at slightly different times, causing
        // flushed txes to be re-added when received from a node which was just about to flush it
        uint32_t mempool_lifetime = m_blockchain.get_mempool_tx_livetime();
        uint64_t max_age = meta.kept_by_block ? CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME : mempool_lifetime;
        if (now - meta.receive_time <= max_age / 2)
        {
          try
          {
            cryptonote::blobdata bd = m_blockchain.get_txpool_tx_blob(txid);
            txs.push_back(std::make_pair(txid, bd));
          }
          catch (const std::exception &e)
          {
            MERROR("Failed to get transaction blob from db");
            // ignore error
          }
        }
      }
      return true;
    }, false);
    return true;
  }

Here is the call graph for this function:

get_transaction()

bool cryptonote::tx_memory_pool::get_transaction	(	const crypto::hash &	h,
		cryptonote::blobdata &	txblob
	)		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

Returns

true if the transaction is found, otherwise false

Definition at line 995 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    try
    {
      return m_blockchain.get_txpool_tx_blob(id, txblob);
    }
    catch (const std::exception &e)
    {
      return false;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_transaction_backlog()

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

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

Parameters

txs	return-by-reference that data
include_unrelayed_txes	include unrelayed txes in the result

Definition at line 763 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    const uint64_t now = time(NULL);
    backlog.reserve(m_blockchain.get_txpool_tx_count(include_unrelayed_txes));
    m_blockchain.for_all_txpool_txes([&backlog, now](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
      backlog.push_back({meta.weight, meta.fee, meta.receive_time - now});
      return true;
    }, false, include_unrelayed_txes);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_transaction_hashes()

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

get a list of all transaction hashes in the pool

Parameters

txs	return-by-reference the list of transactions
include_unrelayed_txes	include unrelayed txes in the result

Definition at line 752 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    txs.reserve(m_blockchain.get_txpool_tx_count(include_unrelayed_txes));
    m_blockchain.for_all_txpool_txes([&txs](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
      txs.push_back(txid);
      return true;
    }, false, include_unrelayed_txes);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_transaction_stats()

void cryptonote::tx_memory_pool::get_transaction_stats	(	struct txpool_stats &	stats,
		bool	include_unrelayed_txes = true
	)		const

get a summary statistics of all transaction hashes in the pool

Parameters

stats	return-by-reference the pool statistics
include_unrelayed_txes	include unrelayed txes in the result

Definition at line 775 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    const uint64_t now = time(NULL);
    std::map<uint64_t, txpool_histo> agebytes;
    stats.txs_total = m_blockchain.get_txpool_tx_count(include_unrelayed_txes);
    std::vector<uint32_t> weights;
    weights.reserve(stats.txs_total);
    m_blockchain.for_all_txpool_txes([&stats, &weights, now, &agebytes](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
      weights.push_back(meta.weight);
      stats.bytes_total += meta.weight;
      if (!stats.bytes_min || meta.weight < stats.bytes_min)
        stats.bytes_min = meta.weight;
      if (meta.weight > stats.bytes_max)
        stats.bytes_max = meta.weight;
      if (!meta.relayed)
        stats.num_not_relayed++;
      stats.fee_total += meta.fee;
      if (!stats.oldest || meta.receive_time < stats.oldest)
        stats.oldest = meta.receive_time;
      if (meta.receive_time < now - 600)
        stats.num_10m++;
      if (meta.last_failed_height)
        stats.num_failing++;
      uint64_t age = now - meta.receive_time + (now == meta.receive_time);
      agebytes[age].txs++;
      agebytes[age].bytes += meta.weight;
      if (meta.double_spend_seen)
        ++stats.num_double_spends;
      if(meta.utxo_nonexistent_seen)
        ++stats.num_nonexistent_utxos;
      return true;
      }, false, include_unrelayed_txes);
    stats.bytes_med = epee::misc_utils::median(weights);
    if (stats.txs_total > 1)
    {
      /* looking for 98th percentile */
      size_t end = stats.txs_total * 0.02;
      uint64_t delta, factor;
      std::map<uint64_t, txpool_histo>::iterator it, i2;
      if (end)
      {
        /* If enough txs, spread the first 98% of results across
         * the first 9 bins, drop final 2% in last bin.
         */
        it=agebytes.end();
        for (size_t n=0; n <= end; n++, it--);
        stats.histo_98pc = it->first;
        factor = 9;
        delta = it->first;
        stats.histo.resize(10);
      } else
      {
        /* If not enough txs, don't reserve the last slot;
         * spread evenly across all 10 bins.
         */
        stats.histo_98pc = 0;
        it = agebytes.end();
        factor = stats.txs_total > 9 ? 10 : stats.txs_total;
        delta = now - stats.oldest;
        stats.histo.resize(factor);
      }
      if (!delta)
        delta = 1;
      for (i2 = agebytes.begin(); i2 != it; i2++)
      {
        size_t i = (i2->first * factor - 1) / delta;
        stats.histo[i].txs += i2->second.txs;
        stats.histo[i].bytes += i2->second.bytes;
      }
      for (; i2 != agebytes.end(); i2++)
      {
        stats.histo[factor].txs += i2->second.txs;
        stats.histo[factor].bytes += i2->second.bytes;
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_transactions()

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

get a list of all transactions in the pool

Parameters

txs	return-by-reference the list of transactions
include_unrelayed_txes	include unrelayed txes in the result

Definition at line 733 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    txs.reserve(m_blockchain.get_txpool_tx_count(include_unrelayed_txes));
    m_blockchain.for_all_txpool_txes([&txs](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
      transaction tx;
      if (!parse_and_validate_tx_from_blob(*bd, tx))
      {
        MERROR("Failed to parse tx from txpool");
        // continue
        return true;
      }
      tx.set_hash(txid);
      txs.push_back(std::move(tx));
      return true;
    }, true, include_unrelayed_txes);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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 = true
	)		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	include unrelayed txes and fields that are sensitive to the node privacy

Returns

true

Definition at line 855 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    tx_infos.reserve(m_blockchain.get_txpool_tx_count());
    key_image_infos.reserve(m_blockchain.get_txpool_tx_count());
    m_blockchain.for_all_txpool_txes([&tx_infos, key_image_infos, include_sensitive_data](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
      tx_info txi;
      txi.id_hash = epee::string_tools::pod_to_hex(txid);
      txi.tx_blob = *bd;
      transaction tx;
      if (!parse_and_validate_tx_from_blob(*bd, tx))
      {
        MERROR("Failed to parse tx from txpool");
        // continue
        return true;
      }
      tx.set_hash(txid);
      txi.tx_json = obj_to_json_str(tx);
      txi.blob_size = bd->size();
      txi.weight = meta.weight;
      txi.fee = meta.fee;
      txi.kept_by_block = meta.kept_by_block;
      txi.max_used_block_height = meta.max_used_block_height;
      txi.max_used_block_id_hash = epee::string_tools::pod_to_hex(meta.max_used_block_id);
      txi.last_failed_height = meta.last_failed_height;
      txi.last_failed_id_hash = epee::string_tools::pod_to_hex(meta.last_failed_id);
      // In restricted mode we do not include this data:
      txi.receive_time = include_sensitive_data ? meta.receive_time : 0;
      txi.relayed = meta.relayed;
      // In restricted mode we do not include this data:
      txi.last_relayed_time = include_sensitive_data ? meta.last_relayed_time : 0;
      txi.do_not_relay = meta.do_not_relay;
      txi.double_spend_seen = meta.double_spend_seen;
      txi.nonexistent_utxo_seen = meta.utxo_nonexistent_seen;
 
      tx_infos.push_back(std::move(txi));
      return true;
    }, true, include_sensitive_data);
 
    txpool_tx_meta_t meta;
    for (const key_images_container::value_type& kee : m_spent_key_images) {
      const crypto::key_image& k_image = kee.first;
      const std::unordered_set<crypto::hash>& kei_image_set = kee.second;
      spent_key_image_info ki;
      ki.id_hash = epee::string_tools::pod_to_hex(k_image);
      for (const crypto::hash& tx_id_hash : kei_image_set)
      {
        if (!include_sensitive_data)
        {
          try
          {
            if (!m_blockchain.get_txpool_tx_meta(tx_id_hash, meta))
            {
              MERROR("Failed to get tx meta from txpool");
              return false;
            }
            if (!meta.relayed)
              // Do not include that transaction if in restricted mode and it's not relayed
              continue;
          }
          catch (const std::exception &e)
          {
            MERROR("Failed to get tx meta from txpool: " << e.what());
            return false;
          }
        }
        ki.txs_hashes.push_back(epee::string_tools::pod_to_hex(tx_id_hash));
      }
      // Only return key images for which we have at least one tx that we can show for them
      if (!ki.txs_hashes.empty())
        key_image_infos.push_back(ki);
    }
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_transactions_count()

size_t cryptonote::tx_memory_pool::get_transactions_count

(

bool

include_unrelayed_txes = true

)

const

get the total number of transactions in the pool

Returns

the number of transactions in the pool

Definition at line 726 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    return m_blockchain.get_txpool_tx_count(include_unrelayed_txes);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 364 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    return m_txpool_weight;
  }

have_tx()

bool cryptonote::tx_memory_pool::have_tx

(

const crypto::hash &

id

)

const

checks if the pool has a transaction with the given hash

Parameters

id	the hash to look for

Returns

true if the transaction is in the pool, otherwise false

Definition at line 1025 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    return m_blockchain.get_db().txpool_has_tx(id);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

init()

bool cryptonote::tx_memory_pool::init

(

size_t

max_txpool_weight = 0

)

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

Parameters

max_txpool_weight

the max weight in bytes

Returns

true

Definition at line 1554 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
 
    m_txpool_max_weight = max_txpool_weight ? max_txpool_weight : DEFAULT_TXPOOL_MAX_WEIGHT;
    m_txs_by_fee_and_receive_time.clear();
    m_spent_key_images.clear();
    m_spent_utxos.clear();
    m_txpool_weight = 0;
    std::vector<crypto::hash> remove;
 
    // first add the not kept by block, then the kept by block,
    // to avoid rejection due to key image collision
    for (int pass = 0; pass < 2; ++pass)
    {
      const bool kept = pass == 1;
      bool r = m_blockchain.for_all_txpool_txes([this, &remove, kept](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd) {
        if (!!kept != !!meta.kept_by_block)
          return true;
        cryptonote::transaction_prefix tx;
        if (!parse_and_validate_tx_prefix_from_blob(*bd, tx))
        {
          MWARNING("Failed to parse tx from txpool, removing");
          remove.push_back(txid);
          return true;
        }
        if (tx.version <= 2 && !insert_key_images(tx, txid, meta.kept_by_block))
        {
          MFATAL("Failed to insert key images from txpool tx");
          return false;
        }
        if (tx.version >= 3 && !insert_utxos(tx, txid, meta.kept_by_block))
        {
          MFATAL("Failed to insert utxos from txpool tx");
          return false;
        }
        m_txs_by_fee_and_receive_time.emplace(std::pair<double, time_t>(meta.fee / (double)meta.weight, meta.receive_time), txid);
        m_txpool_weight += meta.weight;
        return true;
      }, true);
      if (!r)
        return false;
    }
    if (!remove.empty())
    {
      LockedTXN lock(m_blockchain);
      for (const auto &txid: remove)
      {
        try
        {
          m_blockchain.remove_txpool_tx(txid);
        }
        catch (const std::exception &e)
        {
          MWARNING("Failed to remove corrupt transaction: " << txid);
          // ignore error
        }
      }
      lock.commit();
    }
 
    m_cookie = 0;
 
    // Ignore deserialization error
    return true;
  }

Here is the call graph for this function:

lock()

void cryptonote::tx_memory_pool::lock

(

void

)

const

locks the transaction pool

Definition at line 1078 of file tx_pool.cpp.

  {
    m_transactions_lock.lock();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1017 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    m_input_cache.clear();
    m_parsed_tx_cache.clear();
    return 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

Definition at line 1009 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    m_input_cache.clear();
    m_parsed_tx_cache.clear();
    return true;
  }

on_idle()

void cryptonote::tx_memory_pool::on_idle

(

)

action to take periodically

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

Definition at line 587 of file tx_pool.cpp.

  {
    m_remove_stuck_tx_interval.do_call([this](){return remove_stuck_transactions();});
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1325 of file tx_pool.cpp.

  {
    std::stringstream ss;
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    m_blockchain.for_all_txpool_txes([&ss, short_format](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *txblob) {
      ss << "id: " << txid << std::endl;
      if (!short_format) {
        cryptonote::transaction tx;
        if (!parse_and_validate_tx_from_blob(*txblob, tx))
        {
          MERROR("Failed to parse tx from txpool");
          return true; // continue
        }
        ss << obj_to_json_str(tx) << std::endl;
      }
      ss << "blob_size: " << (short_format ? "-" : std::to_string(txblob->size())) << std::endl
        << "weight: " << meta.weight << std::endl
        << "fee: " << print_etn(meta.fee) << std::endl
        << "kept_by_block: " << (meta.kept_by_block ? 'T' : 'F') << std::endl
        << "double_spend_seen: " << (meta.double_spend_seen ? 'T' : 'F') << std::endl
        << "nonexistent_utxo_seen: " << (meta.utxo_nonexistent_seen ? 'T' : 'F') << std::endl
        << "max_used_block_height: " << meta.max_used_block_height << std::endl
        << "max_used_block_id: " << meta.max_used_block_id << std::endl
        << "last_failed_height: " << meta.last_failed_height << std::endl
        << "last_failed_id: " << meta.last_failed_id << std::endl;
      return true;
    }, !short_format);
 
    return ss.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

set_relayed()

void cryptonote::tx_memory_pool::set_relayed

(

const std::vector< std::pair< crypto::hash, cryptonote::blobdata >> &

txs

)

tell the pool that certain transactions were just relayed

Parameters

txs	the list of transactions (and their hashes)

Definition at line 699 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    const time_t now = time(NULL);
    LockedTXN lock(m_blockchain);
    for (auto it = txs.begin(); it != txs.end(); ++it)
    {
      try
      {
        txpool_tx_meta_t meta;
        if (m_blockchain.get_txpool_tx_meta(it->first, meta))
        {
          meta.relayed = true;
          meta.last_relayed_time = now;
          m_blockchain.update_txpool_tx(it->first, meta);
        }
      }
      catch (const std::exception &e)
      {
        MERROR("Failed to update txpool transaction metadata: " << e.what());
        // continue
      }
    }
    lock.commit();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 370 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    m_txpool_max_weight = 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 &	nonexistent_utxo_seen
	)

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?
nonexistent_utxo_seen	return-by-reference was a nonexistent utxo seen for that transaction?

Returns

true unless the transaction cannot be found in the pool

Definition at line 531 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
 
    auto sorted_it = find_tx_in_sorted_container(id);
 
    try
    {
      LockedTXN lock(m_blockchain);
      txpool_tx_meta_t meta;
      if (!m_blockchain.get_txpool_tx_meta(id, meta))
      {
        MERROR("Failed to find tx in txpool");
        return false;
      }
      txblob = m_blockchain.get_txpool_tx_blob(id);
      auto ci = m_parsed_tx_cache.find(id);
      if (ci != m_parsed_tx_cache.end())
      {
        tx = ci->second;
      }
      else if (!parse_and_validate_tx_from_blob(txblob, tx))
      {
        MERROR("Failed to parse tx from txpool");
        return false;
      }
      else
      {
        tx.set_hash(id);
      }
      tx_weight = meta.weight;
      fee = meta.fee;
      relayed = meta.relayed;
      do_not_relay = meta.do_not_relay;
      double_spend_seen = meta.double_spend_seen;
      nonexistent_utxo_seen = meta.utxo_nonexistent_seen;
 
      // remove first, in case this throws, so key images aren't removed
      m_blockchain.remove_txpool_tx(id);
      m_txpool_weight -= tx_weight;
      remove_transaction_keyimages(tx, id);
      lock.commit();
    }
    catch (const std::exception &e)
    {
      MERROR("Failed to remove tx from txpool: " << e.what());
      return false;
    }
 
    if (sorted_it != m_txs_by_fee_and_receive_time.end())
      m_txs_by_fee_and_receive_time.erase(sorted_it);
    ++m_cookie;
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

unlock()

void cryptonote::tx_memory_pool::unlock

(

void

)

const

unlocks the transaction pool

Definition at line 1083 of file tx_pool.cpp.

  {
    m_transactions_lock.unlock();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1490 of file tx_pool.cpp.

  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
    CRITICAL_REGION_LOCAL1(m_blockchain);
    size_t tx_weight_limit = get_transaction_weight_limit(version);
    std::unordered_set<crypto::hash> remove;
 
    m_txpool_weight = 0;
    m_blockchain.for_all_txpool_txes([this, &remove, tx_weight_limit](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata*) {
      m_txpool_weight += meta.weight;
      if (meta.weight > tx_weight_limit) {
        LOG_PRINT_L1("Transaction " << txid << " is too big (" << meta.weight << " bytes), removing it from pool");
        remove.insert(txid);
      }
      else if (m_blockchain.have_tx(txid)) {
        LOG_PRINT_L1("Transaction " << txid << " is in the blockchain, removing it from pool");
        remove.insert(txid);
      }
      return true;
    }, false);
 
    size_t n_removed = 0;
    if (!remove.empty())
    {
      LockedTXN lock(m_blockchain);
      for (const crypto::hash &txid: remove)
      {
        try
        {
          cryptonote::blobdata txblob = m_blockchain.get_txpool_tx_blob(txid);
          cryptonote::transaction tx;
          if (!parse_and_validate_tx_from_blob(txblob, tx))
          {
            MERROR("Failed to parse tx from txpool");
            continue;
          }
          // remove tx from db first
          m_blockchain.remove_txpool_tx(txid);
          m_txpool_weight -= get_transaction_weight(tx, txblob.size());
          remove_transaction_keyimages(tx, txid);
          auto sorted_it = find_tx_in_sorted_container(txid);
          if (sorted_it == m_txs_by_fee_and_receive_time.end())
          {
            LOG_PRINT_L1("Removing tx " << txid << " from tx pool, but it was not found in the sorted txs container!");
          }
          else
          {
            m_txs_by_fee_and_receive_time.erase(sorted_it);
          }
          ++n_removed;
        }
        catch (const std::exception &e)
        {
          MERROR("Failed to remove invalid tx from pool");
          // continue
        }
      }
      lock.commit();
    }
    if (n_removed > 0)
      ++m_cookie;
    return n_removed;
  }

Here is the call graph for this function:

---

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

• /home/abuild/rpmbuild/BUILD/electroneum-4.0.0.0/src/cryptonote_core/tx_pool.h
• /home/abuild/rpmbuild/BUILD/electroneum-4.0.0.0/src/cryptonote_core/tx_pool.cpp