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.
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
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
bool	have_tx (const crypto::hash &id) 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)
	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_unrelayed_txes=true) const
	get a list of all transactions in the pool
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
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
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
bool	utxo_spent_in_pool (const txin_to_key_public &in) 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=true) 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) const
	get a specific transaction from the pool
bool	get_relayable_transactions (std::vector< std::pair< crypto::hash, cryptonote::blobdata > > &txs) const
	get a list of all relayable transactions and their hashes
void	set_relayed (const std::vector< std::pair< crypto::hash, cryptonote::blobdata > > &txs)
	tell the pool that certain transactions were just relayed
size_t	get_transactions_count (bool include_unrelayed_txes=true) 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

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 117 of file tx_pool.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 122 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);
    fee = inputs_amount - outputs_amount;
 
      if(tx.version == 3 && m_blockchain.get_current_blockchain_height() > (m_blockchain.get_nettype() == MAINNET ? 1811310 : 1455270)) {
          if(outputs_amount != inputs_amount)
          {
              LOG_PRINT_L1("transaction fee isnt zero: outputs_amount != inputs_amount, rejecting.");
              tvc.m_verification_failed = true;
              return false;
          }
 
          if(fee != 0){
              LOG_PRINT_L1("We are migrating to aurelius and this transaction should have zero fee and it doesn't, rejecting.");
              tvc.m_verification_failed = true;
              return false;
          }
      }else{
 
          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)
          {
 
              // v1 & v2 tx ins/outs semantics are checked in the same way regardless of our chains height or the network height
              if(tx.version == 1) {
                  LOG_PRINT_L1("v1 transaction fee is zero: outputs_amount == inputs_amount, rejecting.");
                  tvc.m_verification_failed = true;
                  tvc.m_fee_too_low = true;
                  return false;
              }
 
              // for v3 these are fee paying before the final fork, but feeless afterwards.
              // the only way of splitting the two up is by checking the destination, because after the final hard fork,
              // transactions can only go to the bridge (consensus rule elsewhere)
              if(tx.version == 3){
                  //check to see if all outputs are to the bridge address. if so, waive fee, otherwise if feeless return false
                  std::string portal_address_viewkey_hex_str;
                  std::string portal_address_spendkey_hex_str;
                  if(m_blockchain.get_nettype() == MAINNET){
                      portal_address_viewkey_hex_str = "2b95a2eb2c62253c57e82b082b850bbf22a1a7829aaea09c7c1511c1cced4375";
                      portal_address_spendkey_hex_str = "8ce0f34fd37c7f7d07c44024eb5b3cdf275d1b3e75c3464b808dce532e861137";
                  }else{
                      portal_address_viewkey_hex_str = "5866666666666666666666666666666666666666666666666666666666666666"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000
                      portal_address_spendkey_hex_str = "5bd0c0e25eee6133850edd2b255ed9e3d6bb99fd5f08b7b5cf7f2618ad6ff2a3"; //
                  }
                  bool is_sc_migration = true;
                  for (auto output: tx.vout){
                      const auto out = boost::get<txout_to_key_public>(output.target);
                      std::string out_spendkey_str = epee::string_tools::pod_to_hex(out.address.m_spend_public_key.data);
                      std::string out_viewkey_str = epee::string_tools::pod_to_hex(out.address.m_view_public_key.data);
 
                      // If we found an output not going to the bridge, the tx is certainly pre the final hard fork.
                      // so check tx ins/outs semantics here and error/break loop as needed.
                      if(out_spendkey_str != portal_address_spendkey_hex_str || out_viewkey_str !=  portal_address_viewkey_hex_str){
                          is_sc_migration = false;
                          if(inputs_amount <= outputs_amount){
                              LOG_PRINT_L1("pre smartchain migration version 3 tx with wrong amounts: ins " << print_etn(inputs_amount) << ", outs " << print_etn(outputs_amount) << ", rejected for tx id= "
                                                                                                          << get_transaction_hash(tx));
                              return false;
                          }else {
                              break; // we only need to check the overall tx once
                          }
                      }
                  }
 
                  if (is_sc_migration == true && inputs_amount != outputs_amount){
                      LOG_PRINT_L1("version 3 smartchain migration tx should be feeless but has wrong amounts: ins " << print_etn(inputs_amount) << ", outs " << print_etn(outputs_amount) << ", rejected for tx id= "
                                                                                                                   << get_transaction_hash(tx));
                      return false;
                  }
              }
          }
 
          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(tx.version == 3 && m_blockchain.get_current_blockchain_height() > (m_blockchain.get_nettype() == MAINNET ? 1811310 : 1455270)) {
 
          //testing
          //std::string hex_hash = "b166158ee98c5b01252ef6180a1d1ec5f8eced68c947e1a0f2444cf3b9730371";
          //crypto::hash testing_tx_hash;
          //epee::string_tools::hex_to_pod(hex_hash, testing_tx_hash);
          //transaction testing_tx;
          //m_blockchain.get_db().get_tx(testing_tx_hash, testing_tx);
 
          // Block all transactions that don't have valid migration information in the tx extra
          std::vector<tx_extra_field> tx_extra_fields;
          //parse_tx_extra(tx.extra, tx_extra_fields);
          parse_tx_extra(tx.extra, tx_extra_fields);
          cryptonote::tx_extra_bridge_source_address bridge_source_address;
          cryptonote::tx_extra_bridge_smartchain_address  bridge_smartchain_address;
          find_tx_extra_field_by_type(tx_extra_fields, bridge_source_address);
          find_tx_extra_field_by_type(tx_extra_fields, bridge_smartchain_address);
 
          address_parse_info parse_info_dummy;
          if(!cryptonote::get_account_address_from_str(parse_info_dummy, m_blockchain.get_nettype(), bridge_source_address.data)){
              tvc.m_verification_failed = true;
              tvc.m_bad_bridge_source_address = true;
              return false;
          }
 
          // Verify ownership signature: proves the sender controls the spend key of bridge_source_address
          cryptonote::tx_extra_bridge_ownership_sig bridge_ownership_sig;
          if(!find_tx_extra_field_by_type(tx_extra_fields, bridge_ownership_sig) || bridge_ownership_sig.data.size() != sizeof(crypto::signature)){
              tvc.m_verification_failed = true;
              tvc.m_bad_bridge_ownership_sig = true;
              return false;
          }
          std::string sig_message = bridge_source_address.data + bridge_smartchain_address.data;
          crypto::hash sig_hash;
          crypto::cn_fast_hash(sig_message.data(), sig_message.size(), sig_hash);
          crypto::signature ownership_sig;
          memcpy(&ownership_sig, bridge_ownership_sig.data.data(), sizeof(crypto::signature));
          if(!crypto::check_signature(sig_hash, parse_info_dummy.address.m_spend_public_key, ownership_sig)){
              tvc.m_verification_failed = true;
              tvc.m_bad_bridge_ownership_sig = true;
              return false;
          }
 
          // The regular expression pattern for a valid Ethereum address
          bool valid_smartchain_address = true;
          std::string string_smartchain_address = bridge_smartchain_address.data;
          //string_smartchain_address = "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d";
          std::regex pattern("^(0x|0X)[a-fA-F0-9]{40}$");
          if(!std::regex_match(string_smartchain_address, pattern))
              valid_smartchain_address = false;
 
 
          bool isMixedCase = std::any_of(string_smartchain_address.begin(), string_smartchain_address.end(), [](char c) {
              return std::isupper(c);
          }) && std::any_of(string_smartchain_address.begin(), string_smartchain_address.end(), [](char c) {
              return std::islower(c);
          });
 
          if(isMixedCase && valid_smartchain_address != false){ // if it's mixed case, we have to do extra checks
          // Convert the address to lowercase for hashing
          std::string lower_address = string_smartchain_address.substr(2);
          std::transform(lower_address.begin(), lower_address.end(), lower_address.begin(), ::tolower);
 
              unsigned char hashed_lower[32];
              keccak(reinterpret_cast<const uint8_t *>(lower_address.data()), 40, hashed_lower, 32);
              std::string address_hash = epee::string_tools::pod_to_hex(hashed_lower); // should be 0x12ed7467c3852e6b2Bd3C22AF694be8DF7637B10.
 
              std::string hash;
              for (size_t i = 0; i < lower_address.length(); i++) {
                  if (std::isdigit(lower_address[i])) {
                      hash += lower_address[i];
                  }
                  else if (address_hash[i] >= '8') {
                      hash += std::toupper(lower_address[i]);
                  }
                  else {
                      hash += lower_address[i];
                  }
              }
              std::string checksum = hash.substr(0, 8);
              for (size_t i = 2; i < checksum.length() + 2; i++) {
                  if (std::islower(string_smartchain_address[i]) && checksum[i - 2] < 'a') {
                      valid_smartchain_address = false;
                  }
                  else if (std::isupper(string_smartchain_address[i]) && checksum[i - 2] < 'A') {
                      char lower_char = std::tolower(string_smartchain_address[i]);
                      if (checksum[i - 2] != lower_char) {
                          valid_smartchain_address = false;
                      }
                  }
                  else if (checksum[i - 2] != string_smartchain_address[i]) {
                      valid_smartchain_address = false;
                  }
              }
 
          } //end of is mixed case
 
          if(!valid_smartchain_address){
              tvc.m_verification_failed = true;
              tvc.m_bad_bridge_smartchain_address = true;
              return false;
          }
          //BLOCK ALL TX NOT GOING TO THE PORTAL ADDRESS
          std::string portal_address_viewkey_hex_str;
          std::string portal_address_spendkey_hex_str;
          if(m_blockchain.get_nettype() == MAINNET){
              portal_address_viewkey_hex_str = "2b95a2eb2c62253c57e82b082b850bbf22a1a7829aaea09c7c1511c1cced4375";
              portal_address_spendkey_hex_str = "8ce0f34fd37c7f7d07c44024eb5b3cdf275d1b3e75c3464b808dce532e861137";
          }else{
              portal_address_viewkey_hex_str = "5866666666666666666666666666666666666666666666666666666666666666"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000
              portal_address_spendkey_hex_str = "5bd0c0e25eee6133850edd2b255ed9e3d6bb99fd5f08b7b5cf7f2618ad6ff2a3"; //
          }
 
          for (auto output: tx.vout){
              const auto out = boost::get<txout_to_key_public>(output.target);
              std::string out_spendkey_str = epee::string_tools::pod_to_hex(out.address.m_spend_public_key.data);
              std::string out_viewkey_str = epee::string_tools::pod_to_hex(out.address.m_view_public_key.data);
              if(out_spendkey_str != portal_address_spendkey_hex_str || out_viewkey_str !=  portal_address_viewkey_hex_str){
                  tvc.m_verification_failed = true;
                  tvc.m_portal_outbound_tx = true;
                  return false;
              }
          }
      }
 
    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:

Here is the caller 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

◆ 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 1170 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;
  }

◆ cookie()

uint64_t cryptonote::tx_memory_pool::cookie ( ) const

inline

return the cookie

Returns: the cookie

Definition at line 381 of file tx_pool.h.

381{ return m_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)

Definition at line 1819 of file tx_pool.cpp.

  {
    return true;
  }

◆ 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 1554 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:

◆ 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 1121 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:

◆ 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 855 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;
  }

◆ 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 1185 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 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 953 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);
  }

◆ 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 942 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);
  }

◆ 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 965 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:

◆ 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 923 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:

◆ 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 1045 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:

◆ 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 916 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);
  }

◆ 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 554 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 1215 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);
  }

◆ 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 1750 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 ( ) const

locks the transaction pool

Definition at line 1274 of file tx_pool.cpp.

  {
    m_transactions_lock.lock();
  }

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 1207 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 1199 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 777 of file tx_pool.cpp.

  {
    m_remove_stuck_tx_interval.do_call([this](){return remove_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

Definition at line 1521 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:

◆ 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 889 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:

◆ 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 560 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 721 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:

◆ unlock()

void cryptonote::tx_memory_pool::unlock ( ) const

unlocks the transaction pool

Definition at line 1279 of file tx_pool.cpp.

  {
    m_transactions_lock.unlock();
  }

◆ utxo_spent_in_pool()

bool cryptonote::tx_memory_pool::utxo_spent_in_pool ( const txin_to_key_public & in ) const

get a summary statistics of all transaction hashes in the pool

Parameters

in	input to check the pool spent status of

Definition at line 1239 of file tx_pool.cpp.

                                                                           {
      CRITICAL_REGION_LOCAL(m_transactions_lock);
      CRITICAL_REGION_LOCAL1(m_blockchain);
      return have_tx_utxo_as_spent(in);
  }

◆ 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 1686 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-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_core/tx_pool.h
/home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_core/tx_pool.cpp

Classes

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ tx_memory_pool()

Member Function Documentation

◆ add_tx() [1/2]

◆ add_tx() [2/2]

◆ check_for_key_images()

◆ cookie()

◆ deinit()

◆ fill_block_template()

◆ get_pool_for_rpc()

◆ get_relayable_transactions()

◆ get_transaction()

◆ get_transaction_backlog()

◆ get_transaction_hashes()

◆ get_transaction_stats()

◆ get_transactions()

◆ get_transactions_and_spent_keys_info()

◆ get_transactions_count()

◆ get_txpool_weight()

◆ have_tx()

◆ init()

◆ lock()

◆ on_blockchain_dec()

◆ on_blockchain_inc()

◆ on_idle()

◆ print_pool()

◆ set_relayed()

◆ set_txpool_max_weight()

◆ take_tx()

◆ unlock()

◆ utxo_spent_in_pool()

◆ validate()