cryptonote::Blockchain Class Reference

#include <blockchain.h>

Classes
struct	transaction_chain_entry
	Now-defunct (TODO: remove) struct from in-memory blockchain. More...
struct	block_extended_info
	container for passing a block and metadata about it on the blockchain More...

Public Member Functions
	Blockchain (tx_memory_pool &tx_pool)
	Blockchain constructor.
	~Blockchain ()
	Blockchain destructor.
bool	init (BlockchainDB *db, const network_type nettype=MAINNET, bool offline=false, const cryptonote::test_options *test_options=NULL, difficulty_type fixed_difficulty=0, const GetCheckpointsCallback &get_checkpoints=nullptr, bool ignore_bsig=false, bool fallback_to_pow=false)
	Initialize the Blockchain state.
bool	init (BlockchainDB *db, HardFork *&hf, const network_type nettype=MAINNET, bool offline=false)
	Initialize the Blockchain state.
bool	deinit ()
	Uninitializes the blockchain state.
void	set_checkpoints (checkpoints &&chk_pts)
	assign a set of blockchain checkpoint hashes
bool	get_blocks (uint64_t start_offset, size_t count, std::vector< std::pair< cryptonote::blobdata, block > > &blocks, std::vector< cryptonote::blobdata > &txs) const
	get blocks and transactions from blocks based on start height and count
bool	get_blocks (uint64_t start_offset, size_t count, std::vector< std::pair< cryptonote::blobdata, block > > &blocks) const
	get blocks from blocks based on start height and count
bool	get_alternative_blocks (std::vector< block > &blocks) const
	compiles a list of all blocks stored as alternative chains
size_t	get_alternative_blocks_count () const
	returns the number of alternative blocks stored
crypto::hash	get_block_id_by_height (uint64_t height) const
	gets a block's hash given a height
bool	get_block_by_hash (const crypto::hash &h, block &blk, bool *orphan=NULL) const
	gets the block with a given hash
bool	prepare_handle_incoming_blocks (const std::vector< block_complete_entry > &blocks_entry, std::vector< block > &blocks)
	performs some preprocessing on a group of incoming blocks to speed up verification
bool	cleanup_handle_incoming_blocks (bool force_sync=false)
	incoming blocks post-processing, cleanup, and disk sync
bool	have_tx (const crypto::hash &id) const
	search the blockchain for a transaction by hash
bool	key_images_already_spent (const transaction &tx) const
	check if any key image in a transaction has already been spent
bool	utxo_nonexistence_from_output (const txin_to_key_public &public_output) const
	check if a single utxo in a transaction has already been spent using the hash and out index (v3 tx onwards)
bool	utxo_nonexistent (const transaction &tx) const
	check if any utxo in a transaction has already been spent using the tx (v3 tx onwards)
bool	have_tx_keyimg_as_spent (const crypto::key_image &key_im) const
	check if a key image is already spent on the blockchain
uint64_t	get_current_blockchain_height () const
	get the current height of the blockchain
crypto::hash	get_tail_id () const
	get the hash of the most recent block on the blockchain
crypto::hash	get_tail_id (uint64_t &height) const
	get the height and hash of the most recent block on the blockchain
difficulty_type	get_difficulty_for_next_block ()
	returns the difficulty target the next block to be added must meet
void	normalize_v7_difficulties ()
	Normalize the cumulative difficulty for V7 blocks, fixing the differing difficulty among nodes.
bool	add_new_block (const block &bl_, block_verification_context &bvc)
	adds a block to the blockchain
bool	reset_and_set_genesis_block (const block &b)
	clears the blockchain and starts a new one
bool	create_block_template (block &b, const account_public_address &miner_address, difficulty_type &di, uint64_t &height, uint64_t &expected_reward, const blobdata &ex_nonce)
	creates a new block to mine against
bool	create_block_template (block &b, const crypto::hash *from_block, const account_public_address &miner_address, difficulty_type &di, uint64_t &height, uint64_t &expected_reward, const blobdata &ex_nonce)
bool	have_block (const crypto::hash &id) const
	checks if a block is known about with a given hash
size_t	get_total_transactions () const
	gets the total number of transactions on the main chain
bool	get_short_chain_history (std::list< crypto::hash > &ids) const
	gets the hashes for a subset of the blockchain
bool	find_blockchain_supplement (const std::list< crypto::hash > &qblock_ids, std::vector< crypto::hash > &hashes, uint64_t &start_height, uint64_t &current_height, bool clip_pruned) const
	get recent block hashes for a foreign chain
bool	find_blockchain_supplement (const std::list< crypto::hash > &qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request &resp) const
	get recent block hashes for a foreign chain
bool	find_blockchain_supplement (const std::list< crypto::hash > &qblock_ids, uint64_t &starter_offset) const
	find the most recent common point between ours and a foreign chain
bool	find_blockchain_supplement (const uint64_t req_start_block, const std::list< crypto::hash > &qblock_ids, std::vector< std::pair< std::pair< cryptonote::blobdata, crypto::hash >, std::vector< std::pair< crypto::hash, cryptonote::blobdata > > > > &blocks, uint64_t &total_height, uint64_t &start_height, bool pruned, bool get_miner_tx_hash, size_t max_count) const
	get recent blocks for a foreign chain
bool	handle_get_objects (NOTIFY_REQUEST_GET_OBJECTS::request &arg, NOTIFY_RESPONSE_GET_OBJECTS::request &rsp)
	retrieves a set of blocks and their transactions, and possibly other transactions
uint64_t	get_num_mature_outputs (uint64_t amount) const
	get number of outputs of an amount past the minimum spendable age
crypto::public_key	get_output_key (uint64_t amount, uint64_t global_index) const
	get the public key for an output
bool	get_outs (const COMMAND_RPC_GET_OUTPUTS_BIN::request &req, COMMAND_RPC_GET_OUTPUTS_BIN::response &res) const
	gets specific outputs to mix with
void	get_output_key_mask_unlocked (const uint64_t &amount, const uint64_t &index, crypto::public_key &key, rct::key &mask, bool &unlocked) const
	gets an output's key and unlocked state
bool	get_output_distribution (uint64_t amount, uint64_t from_height, uint64_t to_height, uint64_t &start_height, std::vector< uint64_t > &distribution, uint64_t &base) const
	gets per block distribution of outputs of a given amount
bool	get_tx_outputs_gindexs (const crypto::hash &tx_id, std::vector< uint64_t > &indexs) const
	gets the global indices for outputs from a given transaction
bool	get_tx_outputs_gindexs (const crypto::hash &tx_id, size_t n_txes, std::vector< std::vector< uint64_t > > &indexs) const
bool	store_blockchain ()
	stores the blockchain
bool	check_tx_inputs (transaction &tx, uint64_t &pmax_used_block_height, crypto::hash &max_used_block_id, tx_verification_context &tvc, bool kept_by_block=false)
	validates a transaction's inputs
uint64_t	get_dynamic_base_fee_estimate (uint64_t grace_blocks) const
	get dynamic per kB or byte fee estimate for the next few blocks
bool	check_fee (size_t tx_weight, uint64_t fee) const
	validate a transaction's fee
bool	check_tx_outputs (const transaction &tx, tx_verification_context &tvc)
	check that a transaction's outputs conform to current standards
uint64_t	get_current_cumulative_block_weight_limit () const
	gets the block weight limit based on recent blocks
uint64_t	get_next_long_term_block_weight (uint64_t block_weight) const
	gets the long term block weight for a new block
uint64_t	get_current_cumulative_block_weight_median () const
	gets the block weight median based on recent blocks (same window as for the limit)
difficulty_type	block_difficulty (uint64_t i) const
	gets the difficulty of the block with a given height
template<class t_ids_container, class t_blocks_container, class t_missed_container>
bool	get_blocks (const t_ids_container &block_ids, t_blocks_container &blocks, t_missed_container &missed_bs) const
	gets blocks based on a list of block hashes
template<class t_ids_container, class t_tx_container, class t_missed_container>
bool	get_transactions_blobs (const t_ids_container &txs_ids, t_tx_container &txs, t_missed_container &missed_txs, bool pruned=false) const
	gets transactions based on a list of transaction hashes
template<class t_ids_container, class t_tx_container, class t_missed_container>
bool	get_split_transactions_blobs (const t_ids_container &txs_ids, t_tx_container &txs, t_missed_container &missed_txs) const
template<class t_ids_container, class t_tx_container, class t_missed_container>
bool	get_transactions (const t_ids_container &txs_ids, t_tx_container &txs, t_missed_container &missed_txs) const
void	check_against_checkpoints (const checkpoints &points, bool enforce)
	check the blockchain against a set of checkpoints
void	set_enforce_dns_checkpoints (bool enforce)
	configure whether or not to enforce DNS-based checkpoints
bool	update_checkpoints (const std::string &file_path, bool check_dns)
	loads new checkpoints from a file and optionally from DNS
void	set_user_options (uint64_t maxthreads, bool sync_on_blocks, uint64_t sync_threshold, blockchain_db_sync_mode sync_mode, bool fast_sync, std::string validator_key)
	Update the validators public key by fetching data from electroneum's endpoint.
void	set_block_notify (const std::shared_ptr< tools::Notify > &notify)
	sets a block notify object to call for every new block
void	set_reorg_notify (const std::shared_ptr< tools::Notify > &notify)
	sets a reorg notify object to call for every reorg
void	safesyncmode (const bool onoff)
	Put DB in safe sync mode.
void	set_show_time_stats (bool stats)
	set whether or not to show/print time statistics
HardFork::State	get_hard_fork_state () const
	gets the hardfork voting state object
uint8_t	get_current_hard_fork_version () const
	gets the current hardfork version in use/voted for
uint8_t	get_ideal_hard_fork_version () const
	returns the newest hardfork version known to the blockchain
uint8_t	get_next_hard_fork_version () const
	returns the next hardfork version
uint8_t	get_ideal_hard_fork_version (uint64_t height) const
	returns the newest hardfork version voted to be enabled as of a certain height
uint8_t	get_hard_fork_version (uint64_t height) const
	returns the actual hardfork version for a given block height
uint64_t	get_earliest_ideal_height_for_version (uint8_t version) const
	returns the earliest block a given version may activate
bool	get_hard_fork_voting_info (uint8_t version, uint32_t &window, uint32_t &votes, uint32_t &threshold, uint64_t &earliest_height, uint8_t &voting) const
	get information about hardfork voting for a version
uint64_t	get_difficulty_target () const
	get difficulty target based on chain and hardfork version
bool	flush_txes_from_pool (const std::vector< crypto::hash > &txids)
	remove transactions from the transaction pool (if present)
std::map< uint64_t, std::tuple< uint64_t, uint64_t, uint64_t > >	get_output_histogram (const std::vector< uint64_t > &amounts, bool unlocked, uint64_t recent_cutoff, uint64_t min_count=0) const
	return a histogram of outputs on the blockchain
bool	for_all_key_images (std::function< bool(const crypto::key_image &)>) const
	perform a check on all key images in the blockchain
bool	for_blocks_range (const uint64_t &h1, const uint64_t &h2, std::function< bool(uint64_t, const crypto::hash &, const block &)>) const
	perform a check on all blocks in the blockchain in the given range
bool	for_all_transactions (std::function< bool(const crypto::hash &, const cryptonote::transaction &)>, bool pruned) const
	perform a check on all transactions in the blockchain
bool	for_all_outputs (std::function< bool(uint64_t amount, const crypto::hash &tx_hash, uint64_t height, size_t tx_idx)>) const
	perform a check on all outputs in the blockchain
bool	for_all_outputs (uint64_t amount, std::function< bool(uint64_t height)>) const
	perform a check on all outputs of a given amount in the blockchain
const BlockchainDB &	get_db () const
	get a reference to the BlockchainDB in use by Blockchain
BlockchainDB &	get_db ()
	get a reference to the BlockchainDB in use by Blockchain
void	output_scan_worker (const uint64_t amount, const std::vector< uint64_t > &offsets, std::vector< output_data_t > &outputs) const
	get a number of outputs of a specific amount
void	block_longhash_worker (uint64_t height, const epee::span< const block > &blocks, std::unordered_map< crypto::hash, crypto::hash > &map) const
	computes the "short" and "long" hashes for a set of blocks
std::list< std::pair< block_extended_info, std::vector< crypto::hash > > >	get_alternative_chains () const
	returns a set of known alternate chains
void	add_txpool_tx (const crypto::hash &txid, const cryptonote::blobdata &blob, const txpool_tx_meta_t &meta)
void	update_txpool_tx (const crypto::hash &txid, const txpool_tx_meta_t &meta)
void	remove_txpool_tx (const crypto::hash &txid)
uint64_t	get_txpool_tx_count (bool include_unrelayed_txes=true) const
bool	get_txpool_tx_meta (const crypto::hash &txid, txpool_tx_meta_t &meta) const
bool	get_txpool_tx_blob (const crypto::hash &txid, cryptonote::blobdata &bd) const
cryptonote::blobdata	get_txpool_tx_blob (const crypto::hash &txid) const
bool	for_all_txpool_txes (std::function< bool(const crypto::hash &, const txpool_tx_meta_t &, const cryptonote::blobdata *)>, bool include_blob=false, bool include_unrelayed_txes=true) const
uint32_t	get_mempool_tx_livetime () const
bool	is_within_compiled_block_hash_area (uint64_t height) const
bool	is_within_compiled_block_hash_area () const
uint32_t	get_blockchain_pruning_seed () const
bool	prune_blockchain (uint32_t pruning_seed=0)
bool	update_blockchain_pruning ()
bool	check_blockchain_pruning ()
void	lock ()
void	unlock ()
void	cancel ()
void	on_new_tx_from_block (const cryptonote::transaction &tx)
	called when we see a tx originating from a block
std::vector< time_t >	get_last_block_timestamps (unsigned int blocks) const
	returns the timestamps of the last N blocks
void	pop_blocks (uint64_t nblocks)
	removes blocks from the top of the blockchain
void	sign_block (block &b, std::string privateKey)
	Digitally sign the block.
bool	verify_block_signature (const block &b)
	Verify block's digital signature.
void	set_validator_key (std::string key)
	set validator key
void	set_validators_list_instance (std::unique_ptr< electroneum::basic::Validators > &v)
electroneum::basic::Validator	get_validator_by_height (uint64_t height)
network_type	get_nettype () const
	get blockchain nettype
template<class t_ids_container, class t_tx_container, class t_missed_container>
bool	get_transactions_blobs (const t_ids_container &txs_ids, t_tx_container &txs, t_missed_container &missed_txs, bool pruned) const

Static Public Member Functions
static uint64_t	get_fee_quantization_mask ()
	get fee quantization mask
static uint64_t	get_dynamic_base_fee (uint64_t block_reward, size_t median_block_weight, uint8_t version)
	get dynamic per kB or byte fee for a given block weight
static const std::vector< HardFork::Params > &	get_hard_fork_heights (network_type nettype)
	gets the hardfork heights of given network

Detailed Description

Definition at line 97 of file blockchain.h.

Constructor & Destructor Documentation

Blockchain()

Blockchain::Blockchain

(

tx_memory_pool &

tx_pool

)

Blockchain constructor.

Parameters

tx_pool

a reference to the transaction pool to be kept by the Blockchain

Definition at line 146 of file blockchain.cpp.

                                              :
  m_db(), m_tx_pool(tx_pool), m_hardfork(NULL), m_timestamps_and_difficulties_height(0), m_current_block_cumul_weight_limit(0), m_current_block_cumul_weight_median(0),
  m_enforce_dns_checkpoints(false), m_max_prepare_blocks_threads(4), m_db_sync_on_blocks(true), m_db_sync_threshold(1), m_db_sync_mode(db_async), m_db_default_sync(false), m_fast_sync(true), m_show_time_stats(false), m_sync_counter(0), m_bytes_to_sync(0), m_cancel(false),
  m_long_term_block_weights_window(CRYPTONOTE_LONG_TERM_BLOCK_WEIGHT_WINDOW_SIZE),
  m_long_term_effective_median_block_weight(0),
  m_long_term_block_weights_cache_tip_hash(crypto::null_hash),
  m_long_term_block_weights_cache_rolling_median(CRYPTONOTE_LONG_TERM_BLOCK_WEIGHT_WINDOW_SIZE),
  m_difficulty_for_next_block_top_hash(crypto::null_hash),
  m_difficulty_for_next_block(1),
  m_btc_valid(false),
  m_batch_success(true)
{
  LOG_PRINT_L3("Blockchain::" << __func__);
}

~Blockchain()

Blockchain::~Blockchain

(

)

Blockchain destructor.

Definition at line 161 of file blockchain.cpp.

{
  try { deinit(); }
  catch (const std::exception &e) { /* ignore */ }
}

Here is the call graph for this function:

Member Function Documentation

add_new_block()

bool Blockchain::add_new_block	(	const block &	bl_,
		block_verification_context &	bvc )

adds a block to the blockchain

Adds a new block to the blockchain. If the block's parent is not the current top of the blockchain, the block may be added to an alternate chain. If the block does not belong, is already in the blockchain or an alternate chain, or is invalid, return false.

Parameters

bl_	the block to be added
bvc	metadata about the block addition's success/failure

Returns

true on successful addition to the blockchain, else false

Definition at line 4196 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  crypto::hash id = get_block_hash(bl);
  CRITICAL_REGION_LOCAL(m_tx_pool);//to avoid deadlock lets lock tx_pool for whole add/reorganize process
  CRITICAL_REGION_LOCAL1(m_blockchain_lock);
  db_rtxn_guard rtxn_guard(m_db);
  if(have_block(id))
  {
    LOG_PRINT_L3("block with id = " << id << " already exists");
    bvc.m_already_exists = true;
    m_blocks_txs_check.clear();
    return false;
  }
 
  //check that block refers to chain tail
  if(!(bl.prev_id == get_tail_id()))
  {
    //chain switching or wrong block
    bvc.m_added_to_main_chain = false;
    rtxn_guard.stop();
    bool r = handle_alternative_block(bl, id, bvc);
    m_blocks_txs_check.clear();
    return r;
    //never relay alternative blocks
  }
 
  rtxn_guard.stop();
  return handle_block_to_main_chain(bl, id, bvc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_txpool_tx()

void Blockchain::add_txpool_tx	(	const crypto::hash &	txid,
		const cryptonote::blobdata &	blob,
		const txpool_tx_meta_t &	meta )

Definition at line 4768 of file blockchain.cpp.

{
  m_db->add_txpool_tx(txid, blob, meta);
}

block_difficulty()

difficulty_type Blockchain::block_difficulty

(

uint64_t

i

)

const

gets the difficulty of the block with a given height

Parameters

i	the height

Returns

the difficulty

Definition at line 2403 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  try
  {
    return m_db->get_block_difficulty(i);
  }
  catch (const BLOCK_DNE& e)
  {
    MERROR("Attempted to get block difficulty for height above blockchain height");
  }
  return 0;
}

block_longhash_worker()

void Blockchain::block_longhash_worker	(	uint64_t	height,
		const epee::span< const block > &	blocks,
		std::unordered_map< crypto::hash, crypto::hash > &	map ) const

computes the "short" and "long" hashes for a set of blocks

Parameters

height	the height of the first block
blocks	the blocks to be hashed
map	return-by-reference the hashes for each block

Definition at line 4313 of file blockchain.cpp.

{
  TIME_MEASURE_START(t);
  slow_hash_allocate_state();
 
  for (const auto & block : blocks)
  {
    if (m_cancel)
       break;
    crypto::hash id = get_block_hash(block);
    crypto::hash pow = get_block_longhash(block, height++);
    map.emplace(id, pow);
  }
 
  slow_hash_free_state();
  TIME_MEASURE_FINISH(t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cancel()

void Blockchain::cancel

(

)

Definition at line 4933 of file blockchain.cpp.

{
  m_cancel = true;
}

check_against_checkpoints()

void Blockchain::check_against_checkpoints	(	const checkpoints &	points,
		bool	enforce )

check the blockchain against a set of checkpoints

If a block fails a checkpoint and enforce is enabled, the blockchain will be rolled back to two blocks prior to that block. If enforce is disabled, as is currently the default case with DNS-based checkpoints, an error will be printed to the user but no other action will be taken.

Parameters

points	the checkpoints to check against
enforce	whether or not to take action on failure

Definition at line 4229 of file blockchain.cpp.

{
  const auto& pts = points.get_points();
  bool stop_batch;
 
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  stop_batch = m_db->batch_start();
  const uint64_t blockchain_height = m_db->height();
  for (const auto& pt : pts)
  {
    // if the checkpoint is for a block we don't have yet, move on
    if (pt.first >= blockchain_height)
    {
      continue;
    }
 
    if (!points.check_block(pt.first, m_db->get_block_hash_from_height(pt.first)))
    {
      // if asked to enforce checkpoints, roll back to a couple of blocks before the checkpoint
      if (enforce)
      {
        LOG_ERROR("Local blockchain failed to pass a checkpoint, rolling back!");
        std::list<block> empty;
        rollback_blockchain_switching(empty, pt.first - 2);
 
        //Flush the txpool if we've just popped blocks due to failed checkpoint.
        std::vector<crypto::hash> txs;
        m_tx_pool.get_transaction_hashes(txs, true);
        flush_txes_from_pool(txs);
      }
      else
      {
        LOG_ERROR("WARNING: local blockchain failed to pass a ElectroneumPulse checkpoint, and you could be on a fork. You should either sync up from scratch, OR download a fresh blockchain bootstrap, OR enable checkpoint enforcing with the --enforce-dns-checkpointing command-line option");
      }
    }
  }
  if (stop_batch)
    m_db->batch_stop();
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_blockchain_pruning()

bool Blockchain::check_blockchain_pruning

(

)

Definition at line 4091 of file blockchain.cpp.

{
  m_tx_pool.lock();
  epee::misc_utils::auto_scope_leave_caller unlocker = epee::misc_utils::create_scope_leave_handler([&](){m_tx_pool.unlock();});
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  return m_db->check_pruning();
}

Here is the call graph for this function:

check_fee()

bool Blockchain::check_fee	(	size_t	tx_weight,
		uint64_t	fee ) const

validate a transaction's fee

This function validates the fee is enough for the transaction. This is based on the weight of the transaction, and, after a height threshold, on the average weight of transaction in a past window

Parameters

tx_weight	the transaction weight
fee	the fee

Returns

true if the fee is enough, false otherwise

Definition at line 3385 of file blockchain.cpp.

{
  const uint8_t version = get_current_hard_fork_version();
  const uint64_t blockchain_height = m_db->height();
 
  uint64_t median = 0;
  uint64_t already_generated_coins = 0;
  uint64_t base_reward = 0;
  if (version >= HF_VERSION_DYNAMIC_FEE)
  {
    median = m_current_block_cumul_weight_limit / 2;
    const uint64_t blockchain_height = m_db->height();
    already_generated_coins = blockchain_height ? m_db->get_block_already_generated_coins(blockchain_height - 1) : 0;
    if (!get_block_reward(median, 1, already_generated_coins, base_reward, version, blockchain_height, get_nettype()))
      return false;
  }
 
  uint64_t needed_fee;
  if (version >= HF_VERSION_PER_BYTE_FEE)
  {
    const bool use_long_term_median_in_fee = version >= HF_VERSION_LONG_TERM_BLOCK_WEIGHT;
    uint64_t fee_per_byte = get_dynamic_base_fee(base_reward, use_long_term_median_in_fee ? m_long_term_effective_median_block_weight : median, version);
    MDEBUG("Using " << print_etn(fee_per_byte) << "/byte fee");
    needed_fee = tx_weight * fee_per_byte;
    // quantize fee up to 8 decimals
    const uint64_t mask = get_fee_quantization_mask();
    needed_fee = (needed_fee + mask - 1) / mask * mask;
  }
  else
  {
    uint64_t fee_per_kb;
    if (version < HF_VERSION_DYNAMIC_FEE)
    {
      if (version >= 11) {
        fee_per_kb = FEE_PER_KB_V11;
      } else if (version < 11 && version >= 6) {
        fee_per_kb = FEE_PER_KB_V6;
      } else {
        fee_per_kb = FEE_PER_KB;
      }
    }
    else
    {
      fee_per_kb = get_dynamic_base_fee(base_reward, median, version);
    }
    MDEBUG("Using " << print_etn(fee_per_kb) << "/kB fee");
 
    needed_fee = tx_weight / 1024;
    needed_fee += (tx_weight % 1024) ? 1 : 0;
    needed_fee *= fee_per_kb;
  }
 
  if (fee < needed_fee - needed_fee / 50) // keep a little 2% buffer on acceptance - no integer overflow
  {
    MERROR_VER("transaction fee is not enough: " << print_etn(fee) << ", minimum fee: " << print_etn(needed_fee));
    return false;
  }
  return true;
}

Here is the call graph for this function:

check_tx_inputs()

bool cryptonote::Blockchain::check_tx_inputs	(	transaction &	tx,
		uint64_t &	pmax_used_block_height,
		crypto::hash &	max_used_block_id,
		tx_verification_context &	tvc,
		bool	kept_by_block = false )

validates a transaction's inputs

validates a transaction's inputs as correctly used and not previously spent. also returns the hash and height of the most recent block which contains an output that was used as an input to the transaction. The transaction's rct signatures, if any, are expanded.

Parameters

tx	the transaction to validate
pmax_used_block_height	return-by-reference block height of most recent input
max_used_block_id	return-by-reference block hash of most recent input
tvc	returned information about tx verification
kept_by_block	whether or not the transaction is from a previously-verified block

Returns

false if any input is invalid, otherwise true

check_tx_outputs()

bool Blockchain::check_tx_outputs	(	const transaction &	tx,
		tx_verification_context &	tvc )

check that a transaction's outputs conform to current standards

This function checks, for example at the time of this writing, that each output is of the form a * 10^b (phrased differently, that if written out would have only one non-zero digit in base 10).

Parameters

tx	the transaction to check the outputs of
tvc	returned info about tx verification

Returns

false if any outputs do not conform, otherwise true

Definition at line 2901 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  const uint8_t hf_version = m_hardfork->get_current_version();
 
  // from hard fork 2, we forbid dust and compound outputs
  if (hf_version >= HF_VERSION_FORBID_DUST_OUTPUTS) {
    for (auto &o: tx.vout) {
      if (!is_valid_decomposed_amount(o.amount)) {
        tvc.m_invalid_output = true;
        return false;
      }
    }
  }
 
  // from v4, forbid invalid pubkeys
  if (hf_version >= HF_VERSION_FORBID_INVALID_PUBKEYS) {
      for (const auto &o: tx.vout) {
          if (hf_version < HF_VERSION_PUBLIC_TX) {
              if (o.target.type() == typeid(txout_to_key)) {
                  const txout_to_key &out_to_key = boost::get<txout_to_key>(o.target);
                  if (!crypto::check_key(out_to_key.key)) {
                      tvc.m_invalid_output = true;
                      return false;
                  }
              }
          }
          else {
              //do a sanity check on output type before checking destination
              if (o.target.type() != typeid(txout_to_key_public)) {
                  return false;
              }
              const txout_to_key_public &out_to_key_public = boost::get<txout_to_key_public>(o.target);
              if (!crypto::check_key(out_to_key_public.address.m_spend_public_key) ||
                  !crypto::check_key(out_to_key_public.address.m_view_public_key)) {
                  tvc.m_invalid_output = true;
                  return false;
              }
 
              uint64_t address_prefix = get_config(m_nettype).CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX;
              uint64_t integrated_address_prefix = get_config(m_nettype).CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX;
              uint64_t subaddress_prefix = get_config(m_nettype).CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX;
 
              std::vector<uint64_t> supported_prefixes{address_prefix, integrated_address_prefix, subaddress_prefix};
 
              if(std::find(supported_prefixes.begin(), supported_prefixes.end(), out_to_key_public.m_address_prefix) == supported_prefixes.end()) {
                tvc.m_invalid_output = true;
                return false;
              }
          }
      }
  }
  return true;
}

Here is the call graph for this function:

cleanup_handle_incoming_blocks()

bool Blockchain::cleanup_handle_incoming_blocks

(

bool

force_sync = false

)

incoming blocks post-processing, cleanup, and disk sync

Parameters

force_sync

if true, and Blockchain is handling syncing to disk, always sync

Returns

true

Definition at line 4332 of file blockchain.cpp.

{
  bool success = false;
 
  MTRACE("Blockchain::" << __func__);
  CRITICAL_REGION_BEGIN(m_blockchain_lock);
  TIME_MEASURE_START(t1);
 
  try
  {
    if (m_batch_success)
      m_db->batch_stop();
    else
      m_db->batch_abort();
    success = true;
  }
  catch (const std::exception &e)
  {
    MERROR("Exception in cleanup_handle_incoming_blocks: " << e.what());
  }
 
  if (success && m_sync_counter > 0)
  {
    if (force_sync)
    {
      if(m_db_sync_mode != db_nosync)
        store_blockchain();
      m_sync_counter = 0;
    }
    else if (m_db_sync_threshold && ((m_db_sync_on_blocks && m_sync_counter >= m_db_sync_threshold) || (!m_db_sync_on_blocks && m_bytes_to_sync >= m_db_sync_threshold)))
    {
      MDEBUG("Sync threshold met, syncing");
      if(m_db_sync_mode == db_async)
      {
        m_sync_counter = 0;
        m_bytes_to_sync = 0;
        m_async_service.dispatch(boost::bind(&Blockchain::store_blockchain, this));
      }
      else if(m_db_sync_mode == db_sync)
      {
        store_blockchain();
      }
      else // db_nosync
      {
        // DO NOTHING, not required to call sync.
      }
    }
  }
 
  TIME_MEASURE_FINISH(t1);
  m_blocks_longhash_table.clear();
  m_scan_table.clear();
  m_blocks_txs_check.clear();
  m_check_txin_table.clear();
 
  CRITICAL_REGION_END();
  m_tx_pool.unlock();
 
  update_blockchain_pruning();
 
  return success;
}

Here is the call graph for this function:

create_block_template() [1/2]

bool Blockchain::create_block_template	(	block &	b,
		const account_public_address &	miner_address,
		difficulty_type &	di,
		uint64_t &	height,
		uint64_t &	expected_reward,
		const blobdata &	ex_nonce )

creates a new block to mine against

Parameters

b	return-by-reference block to be filled in
from_block	optional block hash to start mining from (main chain tip if NULL)
miner_address	address new coins for the block will go to
di	return-by-reference tells the miner what the difficulty target is
height	return-by-reference tells the miner what height it's mining against
expected_reward	return-by-reference the total reward awarded to the miner finding this block, including transaction fees
ex_nonce	extra data to be added to the miner transaction's extra

Returns

true if block template filled in successfully, else false

Definition at line 1838 of file blockchain.cpp.

{
  return create_block_template(b, NULL, miner_address, diffic, height, expected_reward, ex_nonce);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_block_template() [2/2]

bool Blockchain::create_block_template	(	block &	b,
		const crypto::hash *	from_block,
		const account_public_address &	miner_address,
		difficulty_type &	di,
		uint64_t &	height,
		uint64_t &	expected_reward,
		const blobdata &	ex_nonce )

Definition at line 1583 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  size_t median_weight;
  uint64_t already_generated_coins;
  //uint64_t pool_cookie;
 
  m_tx_pool.lock();
  const auto unlock_guard = epee::misc_utils::create_scope_leave_handler([&]() { m_tx_pool.unlock(); });
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  if (m_btc_valid && !from_block) {
    // The pool cookie is atomic. The lack of locking is OK, as if it changes
    // just as we compare it, we'll just use a slightly old template, but
    // this would be the case anyway if we'd lock, and the change happened
    // just after the block template was created
    if (!memcmp(&miner_address, &m_btc_address, sizeof(cryptonote::account_public_address)) && m_btc_nonce == ex_nonce
      && m_btc_pool_cookie == m_tx_pool.cookie() && m_btc.prev_id == get_tail_id()) {
      MDEBUG("Using cached template");
      m_btc.timestamp = time(NULL); // update timestamp unconditionally
      b = m_btc;
      diffic = m_btc_difficulty;
      height = m_btc_height;
      expected_reward = m_btc_expected_reward;
      return true;
    }
    MDEBUG("Not using cached template: address " << (!memcmp(&miner_address, &m_btc_address, sizeof(cryptonote::account_public_address))) << ", nonce " << (m_btc_nonce == ex_nonce) << ", cookie " << (m_btc_pool_cookie == m_tx_pool.cookie()) << ", from_block " << (!!from_block));
    invalidate_block_template_cache();
  }
 
  if (from_block)
  {
    //build alternative subchain, front -> mainchain, back -> alternative head
    //block is not related with head of main chain
    //first of all - look in alternative chains container
    auto it_prev = m_alternative_chains.find(*from_block);
    bool parent_in_main = m_db->block_exists(*from_block);
    if(it_prev == m_alternative_chains.end() && !parent_in_main)
    {
      MERROR("Unknown from block");
      return false;
    }
 
    //we have new block in alternative chain
    std::list<blocks_ext_by_hash::const_iterator> alt_chain;
    block_verification_context bvc = boost::value_initialized<block_verification_context>();
    std::vector<uint64_t> timestamps;
    if (!build_alt_chain(*from_block, alt_chain, timestamps, bvc))
      return false;
 
    if (parent_in_main)
    {
      cryptonote::block prev_block;
      CHECK_AND_ASSERT_MES(get_block_by_hash(*from_block, prev_block), false, "From block not found"); // TODO
      uint64_t from_block_height = cryptonote::get_block_height(prev_block);
      height = from_block_height + 1;
    }
    else
    {
      height = alt_chain.back()->second.height + 1;
    }
    b.major_version = m_hardfork->get_ideal_version(height);
    b.minor_version = m_hardfork->get_ideal_version();
    b.prev_id = *from_block;
 
    // cheat and use the weight of the block we start from, virtually certain to be acceptable
    // and use 1.9 times rather than 2 times so we're even more sure
    if (parent_in_main)
    {
      median_weight = m_db->get_block_weight(height - 1);
      already_generated_coins = m_db->get_block_already_generated_coins(height - 1);
    }
    else
    {
      median_weight = it_prev->second.block_cumulative_weight - it_prev->second.block_cumulative_weight / 20;
      already_generated_coins = alt_chain.back()->second.already_generated_coins;
    }
 
    // FIXME: consider moving away from block_extended_info at some point
    block_extended_info bei = boost::value_initialized<block_extended_info>();
    bei.bl = b;
    bei.height = alt_chain.size() ? it_prev->second.height + 1 : m_db->get_block_height(*from_block) + 1;
 
    diffic = get_next_difficulty_for_alternative_chain(alt_chain, bei);
  }
  else
  {
    height = m_db->height();
    b.major_version = m_hardfork->get_current_version();
    b.minor_version = m_hardfork->get_ideal_version();
    b.prev_id = get_tail_id();
    median_weight = m_current_block_cumul_weight_limit / 2;
    diffic = get_difficulty_for_next_block();
    already_generated_coins = m_db->get_block_already_generated_coins(height - 1);
  }
  b.timestamp = time(NULL);
 
  uint64_t median_ts;
  if (!check_block_timestamp(b, median_ts))
  {
    b.timestamp = median_ts;
  }
 
  CHECK_AND_ASSERT_MES(diffic, false, "difficulty overhead.");
 
  size_t txs_weight;
  uint64_t fee;
  if (!m_tx_pool.fill_block_template(b, median_weight, already_generated_coins, txs_weight, fee, expected_reward, b.major_version))
  {
    return false;
  }
  //pool_cookie = m_tx_pool.cookie();
#if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
  size_t real_txs_weight = 0;
  uint64_t real_fee = 0;
  for(crypto::hash &cur_hash: b.tx_hashes)
  {
    auto cur_res = m_tx_pool.m_transactions.find(cur_hash);
    if (cur_res == m_tx_pool.m_transactions.end())
    {
      LOG_ERROR("Creating block template: error: transaction not found");
      continue;
    }
    tx_memory_pool::tx_details &cur_tx = cur_res->second;
    real_txs_weight += cur_tx.weight;
    real_fee += cur_tx.fee;
    if (cur_tx.weight != get_transaction_weight(cur_tx.tx))
    {
      LOG_ERROR("Creating block template: error: invalid transaction weight");
    }
 
    uint64_t inputs_amount;
    if (!get_inputs_etn_amount(cur_tx.tx, inputs_amount))
    {
      LOG_ERROR("Creating block template: error: cannot get inputs amount");
    }
    else if (cur_tx.fee != inputs_amount - get_outs_etn_amount(cur_tx.tx))
    {
      LOG_ERROR("Creating block template: error: invalid fee");
    }
  }
  if (txs_weight != real_txs_weight)
  {
    LOG_ERROR("Creating block template: error: wrongly calculated transaction weight");
  }
  if (fee != real_fee)
  {
    LOG_ERROR("Creating block template: error: wrongly calculated fee");
  }
  MDEBUG("Creating block template: height " << height <<
      ", median weight " << median_weight <<
      ", already generated coins " << already_generated_coins <<
      ", transaction weight " << txs_weight <<
      ", fee " << fee);
#endif
 
  /*
   two-phase miner transaction generation: we don't know exact block weight until we prepare block, but we don't know reward until we know
   block weight, so first miner transaction generated with fake amount of etn, and with phase we know think we know expected block weight
   */
  //make blocks coin-base tx looks close to real coinbase tx to get truthful blob weight
  uint8_t hf_version = b.major_version;
  size_t max_outs = hf_version >= 4 ? 1 : 11;
  bool r = construct_miner_tx(height, median_weight, already_generated_coins, txs_weight, fee, miner_address, b.miner_tx, ex_nonce, max_outs, hf_version, m_nettype);
  CHECK_AND_ASSERT_MES(r, false, "Failed to construct miner tx, first chance");
  size_t cumulative_weight = txs_weight + get_transaction_weight(b.miner_tx);
#if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
  MDEBUG("Creating block template: miner tx weight " << get_transaction_weight(b.miner_tx) <<
      ", cumulative weight " << cumulative_weight);
#endif
  for (size_t try_count = 0; try_count != 10; ++try_count)
  {
    r = construct_miner_tx(height, median_weight, already_generated_coins, cumulative_weight, fee, miner_address, b.miner_tx, ex_nonce, max_outs, hf_version, m_nettype);
 
    CHECK_AND_ASSERT_MES(r, false, "Failed to construct miner tx, second chance");
    size_t coinbase_weight = get_transaction_weight(b.miner_tx);
    if (coinbase_weight > cumulative_weight - txs_weight)
    {
      cumulative_weight = txs_weight + coinbase_weight;
#if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
      MDEBUG("Creating block template: miner tx weight " << coinbase_weight <<
          ", cumulative weight " << cumulative_weight << " is greater than before");
#endif
      continue;
    }
 
    if (coinbase_weight < cumulative_weight - txs_weight)
    {
      size_t delta = cumulative_weight - txs_weight - coinbase_weight;
#if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
      MDEBUG("Creating block template: miner tx weight " << coinbase_weight <<
          ", cumulative weight " << txs_weight + coinbase_weight <<
          " is less than before, adding " << delta << " zero bytes");
#endif
      b.miner_tx.extra.insert(b.miner_tx.extra.end(), delta, 0);
      //here  could be 1 byte difference, because of extra field counter is varint, and it can become from 1-byte len to 2-bytes len.
      if (cumulative_weight != txs_weight + get_transaction_weight(b.miner_tx))
      {
        CHECK_AND_ASSERT_MES(cumulative_weight + 1 == txs_weight + get_transaction_weight(b.miner_tx), false, "unexpected case: cumulative_weight=" << cumulative_weight << " + 1 is not equal txs_cumulative_weight=" << txs_weight << " + get_transaction_weight(b.miner_tx)=" << get_transaction_weight(b.miner_tx));
        b.miner_tx.extra.resize(b.miner_tx.extra.size() - 1);
        if (cumulative_weight != txs_weight + get_transaction_weight(b.miner_tx))
        {
          //fuck, not lucky, -1 makes varint-counter size smaller, in that case we continue to grow with cumulative_weight
          MDEBUG("Miner tx creation has no luck with delta_extra size = " << delta << " and " << delta - 1);
          cumulative_weight += delta - 1;
          continue;
        }
        MDEBUG("Setting extra for block: " << b.miner_tx.extra.size() << ", try_count=" << try_count);
      }
    }
    CHECK_AND_ASSERT_MES(cumulative_weight == txs_weight + get_transaction_weight(b.miner_tx), false, "unexpected case: cumulative_weight=" << cumulative_weight << " is not equal txs_cumulative_weight=" << txs_weight << " + get_transaction_weight(b.miner_tx)=" << get_transaction_weight(b.miner_tx));
#if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
    MDEBUG("Creating block template: miner tx weight " << coinbase_weight <<
        ", cumulative weight " << cumulative_weight << " is now good");
#endif
 
    //if (!from_block)
    //  cache_block_template(b, miner_address, ex_nonce, diffic, height, expected_reward, pool_cookie);
 
    if(!m_fallback_to_pow && hf_version >= 8) {
      sign_block(b, m_validator_key);
    }
 
    return true;
  }
  LOG_ERROR("Failed to create_block_template with " << 10 << " tries");
  return false;
}

Here is the call graph for this function:

deinit()

bool Blockchain::deinit

(

)

Uninitializes the blockchain state.

Saves to disk any state that needs to be maintained

Returns

true on success, false if any uninitialization steps fail

Definition at line 660 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
 
  MTRACE("Stopping blockchain read/write activity");
 
 // stop async service
  m_async_work_idle.reset();
  m_async_pool.join_all();
  m_async_service.stop();
 
  // as this should be called if handling a SIGSEGV, need to check
  // if m_db is a NULL pointer (and thus may have caused the illegal
  // memory operation), otherwise we may cause a loop.
  try
  {
    if (m_db)
    {
      m_db->close();
      MTRACE("Local blockchain read/write activity stopped successfully");
    }
  }
  catch (const std::exception& e)
  {
    LOG_ERROR(std::string("Error closing blockchain db: ") + e.what());
  }
  catch (...)
  {
    LOG_ERROR("There was an issue closing/storing the blockchain, shutting down now to prevent issues!");
  }
 
  delete m_hardfork;
  m_hardfork = NULL;
  delete m_db;
  m_db = NULL;
  return true;
}

Here is the caller graph for this function:

find_blockchain_supplement() [1/4]

bool Blockchain::find_blockchain_supplement	(	const std::list< crypto::hash > &	qblock_ids,
		NOTIFY_RESPONSE_CHAIN_ENTRY::request &	resp ) const

get recent block hashes for a foreign chain

Find the split point between us and foreign blockchain and return (by reference) the most recent common block hash along with up to BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT additional (more recent) hashes.

Parameters

qblock_ids	the foreign chain's "short history" (see get_short_chain_history)
resp	return-by-reference the split height and subsequent blocks' hashes

Returns

true if a block found in common, else false

Definition at line 2598 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  bool result = find_blockchain_supplement(qblock_ids, resp.m_block_ids, resp.start_height, resp.total_height, true);
  if (result)
  {
    cryptonote::difficulty_type wide_cumulative_difficulty = m_db->get_block_cumulative_difficulty(resp.total_height - 1);
    resp.cumulative_difficulty = (wide_cumulative_difficulty & 0xffffffffffffffff).convert_to<uint64_t>();
    resp.cumulative_difficulty_top64 = ((wide_cumulative_difficulty >> 64) & 0xffffffffffffffff).convert_to<uint64_t>();
  }
 
  return result;
}

Here is the call graph for this function:

find_blockchain_supplement() [2/4]

bool Blockchain::find_blockchain_supplement	(	const std::list< crypto::hash > &	qblock_ids,
		std::vector< crypto::hash > &	hashes,
		uint64_t &	start_height,
		uint64_t &	current_height,
		bool	clip_pruned ) const

get recent block hashes for a foreign chain

Find the split point between us and foreign blockchain and return (by reference) the most recent common block hash along with up to BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT additional (more recent) hashes.

Parameters

qblock_ids	the foreign chain's "short history" (see get_short_chain_history)
hashes	the hashes to be returned, return-by-reference
start_height	the start height, return-by-reference
current_height	the current blockchain height, return-by-reference
clip_pruned	whether to constrain results to unpruned data

Returns

true if a block found in common, else false

Definition at line 2568 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  // if we can't find the split point, return false
  if(!find_blockchain_supplement(qblock_ids, start_height))
  {
    return false;
  }
 
  db_rtxn_guard rtxn_guard(m_db);
  current_height = get_current_blockchain_height();
  uint64_t stop_height = current_height;
  if (clip_pruned)
  {
    const uint32_t pruning_seed = get_blockchain_pruning_seed();
    start_height = tools::get_next_unpruned_block_height(start_height, current_height, pruning_seed);
    stop_height = tools::get_next_pruned_block_height(start_height, current_height, pruning_seed);
  }
  size_t count = 0;
  hashes.reserve(std::min((size_t)(stop_height - start_height), (size_t)BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT));
  for(size_t i = start_height; i < stop_height && count < BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT; i++, count++)
  {
    hashes.push_back(m_db->get_block_hash_from_height(i));
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_blockchain_supplement() [3/4]

bool Blockchain::find_blockchain_supplement	(	const std::list< crypto::hash > &	qblock_ids,
		uint64_t &	starter_offset ) const

find the most recent common point between ours and a foreign chain

This function takes a list of block hashes from another node on the network to find where the split point is between us and them. This is used to see what to send another node that needs to sync.

Parameters

qblock_ids	the foreign chain's "short history" (see get_short_chain_history)
starter_offset	return-by-reference the most recent common block's height

Returns

true if a block found in common, else false

Definition at line 2348 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  // make sure the request includes at least the genesis block, otherwise
  // how can we expect to sync from the client that the block list came from?
  if(qblock_ids.empty())
  {
    MCERROR("net.p2p", "Client sent wrong NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << qblock_ids.size() << ", dropping connection");
    return false;
  }
 
  db_rtxn_guard rtxn_guard(m_db);
  // make sure that the last block in the request's block list matches
  // the genesis block
  auto gen_hash = m_db->get_block_hash_from_height(0);
  if(qblock_ids.back() != gen_hash)
  {
    LOG_PRINT_L0("Genesis Block Mismatch");
    MCERROR("net.p2p", "Client sent wrong NOTIFY_REQUEST_CHAIN: genesis block mismatch: " << std::endl << "id: " << qblock_ids.back() << ", " << std::endl << "expected: " << gen_hash << "," << std::endl << " dropping connection");
    return false;
  }
 
  // Find the first block the foreign chain has that we also have.
  // Assume qblock_ids is in reverse-chronological order.
  auto bl_it = qblock_ids.begin();
  uint64_t split_height = 0;
  for(; bl_it != qblock_ids.end(); bl_it++)
  {
    try
    {
      if (m_db->block_exists(*bl_it, &split_height))
        break;
    }
    catch (const std::exception& e)
    {
      MWARNING("Non-critical error trying to find block by hash in BlockchainDB, hash: " << *bl_it);
      return false;
    }
  }
 
  // this should be impossible, as we checked that we share the genesis block,
  // but just in case...
  if(bl_it == qblock_ids.end())
  {
    MERROR("Internal error handling connection, can't find split point");
    return false;
  }
 
  //we start to put block ids INCLUDING last known id, just to make other side be sure
  starter_offset = split_height;
  return true;
}

find_blockchain_supplement() [4/4]

bool Blockchain::find_blockchain_supplement	(	const uint64_t	req_start_block,
		const std::list< crypto::hash > &	qblock_ids,
		std::vector< std::pair< std::pair< cryptonote::blobdata, crypto::hash >, std::vector< std::pair< crypto::hash, cryptonote::blobdata > > > > &	blocks,
		uint64_t &	total_height,
		uint64_t &	start_height,
		bool	pruned,
		bool	get_miner_tx_hash,
		size_t	max_count ) const

get recent blocks for a foreign chain

This function gets recent blocks relative to a foreign chain, starting either at a requested height or whatever height is the most recent ours and the foreign chain have in common.

Parameters

req_start_block	if non-zero, specifies a start point (otherwise find most recent commonality)
qblock_ids	the foreign chain's "short history" (see get_short_chain_history)
blocks	return-by-reference the blocks and their transactions
total_height	return-by-reference our current blockchain height
start_height	return-by-reference the height of the first block returned
pruned	whether to return full or pruned tx blobs
max_count	the max number of blocks to get

Returns

true if a block found in common or req_start_block specified, else false

Definition at line 2618 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  // if a specific start height has been requested
  if(req_start_block > 0)
  {
    // if requested height is higher than our chain, return false -- we can't help
    if (req_start_block >= m_db->height())
    {
      return false;
    }
    start_height = req_start_block;
  }
  else
  {
    if(!find_blockchain_supplement(qblock_ids, start_height))
    {
      return false;
    }
  }
 
  db_rtxn_guard rtxn_guard(m_db);
  total_height = get_current_blockchain_height();
  size_t count = 0, size = 0;
  blocks.reserve(std::min(std::min(max_count, (size_t)10000), (size_t)(total_height - start_height)));
  for(uint64_t i = start_height; i < total_height && count < max_count && (size < FIND_BLOCKCHAIN_SUPPLEMENT_MAX_SIZE || count < 3); i++, count++)
  {
    blocks.resize(blocks.size()+1);
    blocks.back().first.first = m_db->get_block_blob_from_height(i);
    block b;
    CHECK_AND_ASSERT_MES(parse_and_validate_block_from_blob(blocks.back().first.first, b), false, "internal error, invalid block");
    blocks.back().first.second = get_miner_tx_hash ? cryptonote::get_transaction_hash(b.miner_tx) : crypto::null_hash;
    std::vector<crypto::hash> mis;
    std::vector<cryptonote::blobdata> txs;
    get_transactions_blobs(b.tx_hashes, txs, mis, pruned);
    CHECK_AND_ASSERT_MES(!mis.size(), false, "internal error, transaction from block not found");
    size += blocks.back().first.first.size();
    for (const auto &t: txs)
      size += t.size();
 
    CHECK_AND_ASSERT_MES(txs.size() == b.tx_hashes.size(), false, "mismatched sizes of b.tx_hashes and txs");
    blocks.back().second.reserve(txs.size());
    for (size_t i = 0; i < txs.size(); ++i)
    {
      blocks.back().second.push_back(std::make_pair(b.tx_hashes[i], std::move(txs[i])));
    }
  }
  return true;
}

Here is the call graph for this function:

flush_txes_from_pool()

bool Blockchain::flush_txes_from_pool

(

const std::vector< crypto::hash > &

txids

)

remove transactions from the transaction pool (if present)

Parameters

txids

a list of hashes of transactions to be removed

Returns

false if any removals fail, otherwise true

Definition at line 3657 of file blockchain.cpp.

{
  CRITICAL_REGION_LOCAL(m_tx_pool);
 
  bool res = true;
  for (const auto &txid: txids)
  {
    cryptonote::transaction tx;
    cryptonote::blobdata txblob;
    size_t tx_weight;
    uint64_t fee;
    bool relayed, do_not_relay, double_spend_seen, nonexistent_utxo_seen;
    MINFO("Removing txid " << txid << " from the pool");
    if(m_tx_pool.have_tx(txid) && !m_tx_pool.take_tx(txid, tx, txblob, tx_weight, fee, relayed, do_not_relay, double_spend_seen, nonexistent_utxo_seen))
    {
      MERROR("Failed to remove txid " << txid << " from the pool");
      res = false;
    }
  }
  return res;
}

Here is the caller graph for this function:

for_all_key_images()

bool Blockchain::for_all_key_images

(

std::function< bool(const crypto::key_image &)>

)

const

perform a check on all key images in the blockchain

Parameters

std::function

the check to perform, pass/fail

Returns

false if any key image fails the check, otherwise true

Definition at line 5041 of file blockchain.cpp.

{
  return m_db->for_all_key_images(f);
}

for_all_outputs() [1/2]

bool cryptonote::Blockchain::for_all_outputs

(

std::function< bool(uint64_t amount, const crypto::hash &tx_hash, uint64_t height, size_t tx_idx)>

)

const

perform a check on all outputs in the blockchain

Parameters

std::function

the check to perform, pass/fail

Returns

false if any output fails the check, otherwise true

for_all_outputs() [2/2]

bool cryptonote::Blockchain::for_all_outputs	(	uint64_t	amount,
		std::function< bool(uint64_t height)>	) const

perform a check on all outputs of a given amount in the blockchain

Parameters

amount	the amount to iterate through
std::function	the check to perform, pass/fail

Returns

false if any output fails the check, otherwise true

for_all_transactions()

bool Blockchain::for_all_transactions	(	std::function< bool(const crypto::hash &, const cryptonote::transaction &)>	,
		bool	pruned ) const

perform a check on all transactions in the blockchain

Parameters

std::function	the check to perform, pass/fail
bool	pruned whether to return pruned txes only

Returns

false if any transaction fails the check, otherwise true

Definition at line 5051 of file blockchain.cpp.

{
  return m_db->for_all_transactions(f, pruned);
}

for_all_txpool_txes()

bool Blockchain::for_all_txpool_txes	(	std::function< bool(const crypto::hash &, const txpool_tx_meta_t &, const cryptonote::blobdata *)>	,
		bool	include_blob = false,
		bool	include_unrelayed_txes = true ) const

Definition at line 4803 of file blockchain.cpp.

{
  return m_db->for_all_txpool_txes(f, include_blob, include_unrelayed_txes);
}

for_blocks_range()

bool Blockchain::for_blocks_range	(	const uint64_t &	h1,
		const uint64_t &	h2,
		std::function< bool(uint64_t, const crypto::hash &, const block &)>	) const

perform a check on all blocks in the blockchain in the given range

Parameters

h1	the start height
h2	the end height
std::function	the check to perform, pass/fail

Returns

false if any block fails the check, otherwise true

Definition at line 5046 of file blockchain.cpp.

{
  return m_db->for_blocks_range(h1, h2, f);
}

get_alternative_blocks()

bool Blockchain::get_alternative_blocks

(

std::vector< block > &

blocks

)

const

compiles a list of all blocks stored as alternative chains

Parameters

blocks

return-by-reference container to put result blocks in

Returns

true

Definition at line 2193 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  blocks.reserve(m_alternative_chains.size());
  for (const auto& alt_bl: m_alternative_chains)
  {
    blocks.push_back(alt_bl.second.bl);
  }
  return true;
}

get_alternative_blocks_count()

size_t Blockchain::get_alternative_blocks_count

(

)

const

returns the number of alternative blocks stored

Returns

the number of alternative blocks stored

Definition at line 2206 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  return m_alternative_chains.size();
}

get_alternative_chains()

std::list< std::pair< Blockchain::block_extended_info, std::vector< crypto::hash > > > Blockchain::get_alternative_chains

(

)

const

returns a set of known alternate chains

Returns

a list of chains

Definition at line 4900 of file blockchain.cpp.

{
  std::list<std::pair<Blockchain::block_extended_info,std::vector<crypto::hash>>> chains;
 
  for (const auto &i: m_alternative_chains)
  {
    const crypto::hash &top = i.first;
    bool found = false;
    for (const auto &j: m_alternative_chains)
    {
      if (j.second.bl.prev_id == top)
      {
        found = true;
        break;
      }
    }
    if (!found)
    {
      std::vector<crypto::hash> chain;
      auto h = i.second.bl.prev_id;
      chain.push_back(top);
      blocks_ext_by_hash::const_iterator prev;
      while ((prev = m_alternative_chains.find(h)) != m_alternative_chains.end())
      {
        chain.push_back(h);
        h = prev->second.bl.prev_id;
      }
      chains.push_back(std::make_pair(i.second, chain));
    }
  }
  return chains;
}

get_block_by_hash()

bool Blockchain::get_block_by_hash	(	const crypto::hash &	h,
		block &	blk,
		bool *	orphan = NULL ) const

gets the block with a given hash

Parameters

h	the hash to look for
blk	return-by-reference variable to put result block in
orphan	if non-NULL, will be set to true if not in the main chain, false otherwise

Returns

true if the block was found, else false

Definition at line 928 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  // try to find block in main chain
  try
  {
    blk = m_db->get_block(h);
    if (orphan)
      *orphan = false;
    return true;
  }
  // try to find block in alternative chain
  catch (const BLOCK_DNE& e)
  {
    blocks_ext_by_hash::const_iterator it_alt = m_alternative_chains.find(h);
    if (m_alternative_chains.end() != it_alt)
    {
      blk = it_alt->second.bl;
      if (orphan)
        *orphan = true;
      return true;
    }
  }
  catch (const std::exception& e)
  {
    MERROR(std::string("Something went wrong fetching block by hash: ") + e.what());
    throw;
  }
  catch (...)
  {
    MERROR(std::string("Something went wrong fetching block hash by hash"));
    throw;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_id_by_height()

crypto::hash Blockchain::get_block_id_by_height

(

uint64_t

height

)

const

gets a block's hash given a height

Parameters

height

the height of the block

Returns

the hash of the block at the requested height, or a zeroed hash if there is no such block

Definition at line 901 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  try
  {
    return m_db->get_block_hash_from_height(height);
  }
  catch (const BLOCK_DNE& e)
  {
  }
  catch (const std::exception& e)
  {
    MERROR(std::string("Something went wrong fetching block hash by height: ") + e.what());
    throw;
  }
  catch (...)
  {
    MERROR(std::string("Something went wrong fetching block hash by height"));
    throw;
  }
  return null_hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_blockchain_pruning_seed()

uint32_t cryptonote::Blockchain::get_blockchain_pruning_seed ( ) const

inline

Definition at line 1017 of file blockchain.h.

{ return m_db->get_blockchain_pruning_seed(); }

Here is the caller graph for this function:

get_blocks() [1/3]

template<class t_ids_container, class t_blocks_container, class t_missed_container>

bool Blockchain::get_blocks	(	const t_ids_container &	block_ids,
		t_blocks_container &	blocks,
		t_missed_container &	missed_bs ) const

gets blocks based on a list of block hashes

Template Parameters

t_ids_container	a standard-iterable container
t_blocks_container	a standard-iterable container
t_missed_container	a standard-iterable container

Parameters

block_ids	a container of block hashes for which to get the corresponding blocks
blocks	return-by-reference a container to store result blocks in
missed_bs	return-by-reference a container to store missed blocks in

Returns

false if an unexpected exception occurs, else true

Definition at line 2427 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  reserve_container(blocks, block_ids.size());
  for (const auto& block_hash : block_ids)
  {
    try
    {
      uint64_t height = 0;
      if (m_db->block_exists(block_hash, &height))
      {
        blocks.push_back(std::make_pair(m_db->get_block_blob_from_height(height), block()));
        if (!parse_and_validate_block_from_blob(blocks.back().first, blocks.back().second))
        {
          LOG_ERROR("Invalid block: " << block_hash);
          blocks.pop_back();
          missed_bs.push_back(block_hash);
        }
      }
      else
        missed_bs.push_back(block_hash);
    }
    catch (const std::exception& e)
    {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

get_blocks() [2/3]

bool Blockchain::get_blocks	(	uint64_t	start_offset,
		size_t	count,
		std::vector< std::pair< cryptonote::blobdata, block > > &	blocks ) const

get blocks from blocks based on start height and count

Parameters

start_offset	the height on the blockchain to start at
count	the number of blocks to get, if there are as many after start_offset
blocks	return-by-reference container to put result blocks in

Returns

false if start_offset > blockchain height, else true

Definition at line 2118 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  const uint64_t height = m_db->height();
  if(start_offset >= height)
    return false;
 
  blocks.reserve(blocks.size() + height - start_offset);
  for(size_t i = start_offset; i < start_offset + count && i < height;i++)
  {
    blocks.push_back(std::make_pair(m_db->get_block_blob_from_height(i), block()));
    if (!parse_and_validate_block_from_blob(blocks.back().first, blocks.back().second))
    {
      LOG_ERROR("Invalid block");
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

get_blocks() [3/3]

bool Blockchain::get_blocks	(	uint64_t	start_offset,
		size_t	count,
		std::vector< std::pair< cryptonote::blobdata, block > > &	blocks,
		std::vector< cryptonote::blobdata > &	txs ) const

get blocks and transactions from blocks based on start height and count

Parameters

start_offset	the height on the blockchain to start at
count	the number of blocks to get, if there are as many after start_offset
blocks	return-by-reference container to put result blocks in
txs	return-by-reference container to put result transactions in

Returns

false if start_offset > blockchain height, else true

Definition at line 2096 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  if(start_offset >= m_db->height())
    return false;
 
  if (!get_blocks(start_offset, count, blocks))
  {
    return false;
  }
 
  for(const auto& blk : blocks)
  {
    std::vector<crypto::hash> missed_ids;
    get_transactions_blobs(blk.second.tx_hashes, txs, missed_ids);
    CHECK_AND_ASSERT_MES(!missed_ids.size(), false, "has missed transactions in own block in main blockchain");
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_blockchain_height()

uint64_t Blockchain::get_current_blockchain_height

(

)

const

get the current height of the blockchain

Returns

the height

Definition at line 322 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  return m_db->height();
}

Here is the caller graph for this function:

get_current_cumulative_block_weight_limit()

uint64_t Blockchain::get_current_cumulative_block_weight_limit

(

)

const

gets the block weight limit based on recent blocks

Returns

the limit

Definition at line 1560 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  return m_current_block_cumul_weight_limit;
}

get_current_cumulative_block_weight_median()

uint64_t Blockchain::get_current_cumulative_block_weight_median

(

)

const

gets the block weight median based on recent blocks (same window as for the limit)

Returns

the median

Definition at line 1566 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  return m_current_block_cumul_weight_median;
}

get_current_hard_fork_version()

uint8_t cryptonote::Blockchain::get_current_hard_fork_version ( ) const

inline

gets the current hardfork version in use/voted for

Returns

the version

Definition at line 825 of file blockchain.h.

{ return m_hardfork->get_current_version(); }

Here is the caller graph for this function:

get_db() [1/2]

BlockchainDB & cryptonote::Blockchain::get_db ( )

inline

get a reference to the BlockchainDB in use by Blockchain

Returns

a reference to the BlockchainDB instance

Definition at line 973 of file blockchain.h.

    {
      return *m_db;
    }

get_db() [2/2]

const BlockchainDB & cryptonote::Blockchain::get_db ( ) const

inline

get a reference to the BlockchainDB in use by Blockchain

Returns

a reference to the BlockchainDB instance

Definition at line 963 of file blockchain.h.

    {
      return *m_db;
    }

Here is the caller graph for this function:

get_difficulty_for_next_block()

difficulty_type Blockchain::get_difficulty_for_next_block

(

)

returns the difficulty target the next block to be added must meet

Returns

the target

Definition at line 971 of file blockchain.cpp.

{
  if (m_fixed_difficulty)
  {
    return m_db->height() ? m_fixed_difficulty : 1;
  }
 
  LOG_PRINT_L3("Blockchain::" << __func__);
 
  crypto::hash top_hash = get_tail_id();
  {
    CRITICAL_REGION_LOCAL(m_difficulty_lock);
    // we can call this without the blockchain lock, it might just give us
    // something a bit out of date, but that's fine since anything which
    // requires the blockchain lock will have acquired it in the first place,
    // and it will be unlocked only when called from the getinfo RPC
    if (top_hash == m_difficulty_for_next_block_top_hash)
      return m_difficulty_for_next_block;
  }
 
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  std::vector<uint64_t> timestamps;
  std::vector<difficulty_type> difficulties;
  uint64_t height;
  top_hash = get_tail_id(height); // get it again now that we have the lock
  ++height; // top block height to blockchain height
 
  uint64_t v6height = 0, v7height = 0, v8height = 0;
  if(m_nettype == MAINNET) {
    v6height = mainnet_hard_forks[1].height;
    v7height = mainnet_hard_forks[2].height;
    v8height = mainnet_hard_forks[3].height;
  } else if(m_nettype == TESTNET) {
    v6height = testnet_hard_forks[1].height;
    v7height = testnet_hard_forks[2].height;
    v8height = testnet_hard_forks[3].height;
  } else if(m_nettype == STAGENET) {
    v6height = stagenet_hard_forks[5].height;
    v7height = stagenet_hard_forks[5].height;
    v8height = stagenet_hard_forks[5].height;
  } else if(m_nettype == UNDEFINED){
    MERROR(std::string("Something went wrong defining the network type."));
  }
 
 
    uint32_t difficultyBlocksCount = (height >= v6height && height < v7height) ? DIFFICULTY_BLOCKS_COUNT_V6 : DIFFICULTY_BLOCKS_COUNT;
 
  // After v8 allow the difficulty window to grow linearly (from zero) back to DIFFICULTY_BLOCKS_COUNT.
  if((height >= v8height) && (height < v8height + 720))
  {
    // Initial clear of the caches when we hit v8.
    if(height == v8height)
    {
      m_timestamps.clear();
      m_difficulties.clear();
    }
    difficultyBlocksCount = height - v8height;
  }
 
  // ND: Speedup
  // 1. Keep a list of the last 735 (or less) blocks that is used to compute difficulty,
  //    then when the next block difficulty is queried, push the latest height data and
  //    pop the oldest one from the list. This only requires 1x read per height instead
  //    of doing 735 (DIFFICULTY_BLOCKS_COUNT).
  // Post v8 we will only re-enter this scope after the first DIFFICULTY_BLOCKS_COUNT blocks due to the last condition.
  if (m_timestamps_and_difficulties_height != 0 && ((height - m_timestamps_and_difficulties_height) == 1) && m_timestamps.size() >= difficultyBlocksCount)
  {
    uint64_t index = height - 1;
    m_timestamps.push_back(m_db->get_block_timestamp(index));
    m_difficulties.push_back(m_db->get_block_cumulative_difficulty(index));
 
    while (m_timestamps.size() > difficultyBlocksCount)
      m_timestamps.erase(m_timestamps.begin());
    while (m_difficulties.size() > difficultyBlocksCount)
      m_difficulties.erase(m_difficulties.begin());
 
    m_timestamps_and_difficulties_height = height;
    timestamps = m_timestamps;
    difficulties = m_difficulties;
  }
  else
  {
    uint64_t offset = height - std::min < uint64_t > (height, static_cast<uint64_t>(difficultyBlocksCount));
    if (offset == 0)
      ++offset;
 
    timestamps.clear();
    difficulties.clear();
    if (height > offset)
    {
      timestamps.reserve(height - offset);
      difficulties.reserve(height - offset);
    }
    for (; offset < height; offset++)
    {
      timestamps.push_back(m_db->get_block_timestamp(offset));
      difficulties.push_back(m_db->get_block_cumulative_difficulty(offset));
    }
 
    m_timestamps_and_difficulties_height = height;
    m_timestamps = timestamps;
    m_difficulties = difficulties;
  }
  size_t target = get_difficulty_target();
  const uint8_t version = (height >= v6height && height < v7height) ? 6 : 1;
  difficulty_type diff = next_difficulty(timestamps, difficulties, target, version);
 
  CRITICAL_REGION_LOCAL1(m_difficulty_lock);
  m_difficulty_for_next_block_top_hash = top_hash;
  m_difficulty_for_next_block = diff;
  return diff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_difficulty_target()

uint64_t Blockchain::get_difficulty_target

(

)

const

get difficulty target based on chain and hardfork version

Returns

difficulty target

Definition at line 4890 of file blockchain.cpp.

{
  return get_current_hard_fork_version() < 6 ? DIFFICULTY_TARGET : DIFFICULTY_TARGET_V6;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_dynamic_base_fee()

uint64_t Blockchain::get_dynamic_base_fee ( uint64_t block_reward, size_t median_block_weight, uint8_t version )

static

get dynamic per kB or byte fee for a given block weight

The dynamic fee is based on the block weight in a past window, and the current block reward. It is expressed by kB before v8, and per byte from v8.

Parameters

block_reward	the current block reward
median_block_weight	the median block weight in the past window
version	hard fork version for rules and constants to use

Returns

the fee

Definition at line 3347 of file blockchain.cpp.

{
  const uint64_t min_block_weight = get_min_block_weight(version);
  if (median_block_weight < min_block_weight)
    median_block_weight = min_block_weight;
  uint64_t hi, lo;
 
  if (version >= HF_VERSION_PER_BYTE_FEE)
  {
    lo = mul128(block_reward, DYNAMIC_FEE_REFERENCE_TRANSACTION_WEIGHT, &hi);
    div128_32(hi, lo, min_block_weight, &hi, &lo);
    div128_32(hi, lo, median_block_weight, &hi, &lo);
    assert(hi == 0);
    lo /= 5;
    return lo;
  }
 
  const uint64_t fee_base = version >= 5 ? DYNAMIC_FEE_PER_KB_BASE_FEE_V5 : DYNAMIC_FEE_PER_KB_BASE_FEE;
 
  uint64_t unscaled_fee_base = (fee_base * min_block_weight / median_block_weight);
  lo = mul128(unscaled_fee_base, block_reward, &hi);
  static_assert(DYNAMIC_FEE_PER_KB_BASE_BLOCK_REWARD % 1000000 == 0, "DYNAMIC_FEE_PER_KB_BASE_BLOCK_REWARD must be divisible by 1000000");
  static_assert(DYNAMIC_FEE_PER_KB_BASE_BLOCK_REWARD / 1000000 <= std::numeric_limits<uint32_t>::max(), "DYNAMIC_FEE_PER_KB_BASE_BLOCK_REWARD is too large");
 
  // divide in two steps, since the divisor must be 32 bits, but DYNAMIC_FEE_PER_KB_BASE_BLOCK_REWARD isn't
  div128_32(hi, lo, DYNAMIC_FEE_PER_KB_BASE_BLOCK_REWARD / 1000000, &hi, &lo);
  div128_32(hi, lo, 1000000, &hi, &lo);
  assert(hi == 0);
 
  // quantize fee up to 8 decimals
  uint64_t mask = get_fee_quantization_mask();
  uint64_t qlo = (lo + mask - 1) / mask * mask;
  MDEBUG("lo " << print_etn(lo) << ", qlo " << print_etn(qlo) << ", mask " << mask);
 
  return qlo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_dynamic_base_fee_estimate()

uint64_t Blockchain::get_dynamic_base_fee_estimate

(

uint64_t

grace_blocks

)

const

get dynamic per kB or byte fee estimate for the next few blocks

The dynamic fee is based on the block weight in a past window, and the current block reward. It is expressed by kB before v8, and per byte from v8. This function calculates an estimate for a dynamic fee which will be valid for the next grace_blocks

Parameters

grace_blocks

number of blocks we want the fee to be valid for

Returns

the fee estimate

Definition at line 3446 of file blockchain.cpp.

{
  const uint8_t version = get_current_hard_fork_version();
  const uint64_t db_height = m_db->height();
 
  if (version < HF_VERSION_DYNAMIC_FEE) {
    if (version >= 11) {
      return FEE_PER_KB_V11;
    } else if (version < 11 && version >= 6) {
      return FEE_PER_KB_V6;
    } else {
      return FEE_PER_KB;
    } 
  }
 
  if (grace_blocks >= CRYPTONOTE_REWARD_BLOCKS_WINDOW)
    grace_blocks = CRYPTONOTE_REWARD_BLOCKS_WINDOW - 1;
 
  const uint64_t min_block_weight = get_min_block_weight(version);
  std::vector<uint64_t> weights;
  get_last_n_blocks_weights(weights, CRYPTONOTE_REWARD_BLOCKS_WINDOW - grace_blocks);
  weights.reserve(grace_blocks);
  for (size_t i = 0; i < grace_blocks; ++i)
    weights.push_back(min_block_weight);
 
  uint64_t median = epee::misc_utils::median(weights);
  if(median <= min_block_weight)
    median = min_block_weight;
 
  uint64_t already_generated_coins = db_height ? m_db->get_block_already_generated_coins(db_height - 1) : 0;
  uint64_t base_reward;
  if (!get_block_reward(median, 1, already_generated_coins, base_reward, version, get_current_blockchain_height(), get_nettype()))
  {
    MERROR("Failed to determine block reward, using placeholder " << print_etn(BLOCK_REWARD_OVERESTIMATE) << " as a high bound");
    base_reward = BLOCK_REWARD_OVERESTIMATE;
  }
 
  const bool use_long_term_median_in_fee = version >= HF_VERSION_LONG_TERM_BLOCK_WEIGHT;
  uint64_t fee = get_dynamic_base_fee(base_reward, use_long_term_median_in_fee ? m_long_term_effective_median_block_weight : median, version);
  const bool per_byte = version < HF_VERSION_PER_BYTE_FEE;
  MDEBUG("Estimating " << grace_blocks << "-block fee at " << print_etn(fee) << "/" << (per_byte ? "byte" : "kB"));
  return fee;
}

Here is the call graph for this function:

get_earliest_ideal_height_for_version()

uint64_t cryptonote::Blockchain::get_earliest_ideal_height_for_version ( uint8_t version ) const

inline

returns the earliest block a given version may activate

Returns

the height

Definition at line 865 of file blockchain.h.

{ return m_hardfork->get_earliest_ideal_height_for_version(version); }

Here is the caller graph for this function:

get_fee_quantization_mask()

uint64_t Blockchain::get_fee_quantization_mask ( )

static

get fee quantization mask

The dynamic fee may be quantized, to mask out the last decimal places

Returns

the fee quantized mask

Definition at line 3334 of file blockchain.cpp.

{
  static uint64_t mask = 0;
  if (mask == 0)
  {
    mask = 1;
    for (size_t n = PER_KB_FEE_QUANTIZATION_DECIMALS; n < CRYPTONOTE_DISPLAY_DECIMAL_POINT; ++n)
      mask *= 10;
  }
  return mask;
}

Here is the caller graph for this function:

get_hard_fork_heights()

const std::vector< HardFork::Params > & Blockchain::get_hard_fork_heights ( network_type nettype )

static

gets the hardfork heights of given network

Returns

the HardFork object

Definition at line 4852 of file blockchain.cpp.

{
  static const std::vector<HardFork::Params> mainnet_heights = []()
  {
    std::vector<HardFork::Params> heights;
    for (const auto& i : mainnet_hard_forks)
      heights.emplace_back(i.version, i.height, i.threshold, i.time);
    return heights;
  }();
  static const std::vector<HardFork::Params> testnet_heights = []()
  {
    std::vector<HardFork::Params> heights;
    for (const auto& i : testnet_hard_forks)
      heights.emplace_back(i.version, i.height, i.threshold, i.time);
    return heights;
  }();
  static const std::vector<HardFork::Params> stagenet_heights = []()
  {
    std::vector<HardFork::Params> heights;
    for (const auto& i : stagenet_hard_forks)
      heights.emplace_back(i.version, i.height, i.threshold, i.time);
    return heights;
  }();
  static const std::vector<HardFork::Params> dummy;
  switch (nettype)
  {
    case MAINNET: return mainnet_heights;
    case TESTNET: return testnet_heights;
    case STAGENET: return stagenet_heights;
    default: return dummy;
  }
}

Here is the caller graph for this function:

get_hard_fork_state()

HardFork::State Blockchain::get_hard_fork_state

(

)

const

gets the hardfork voting state object

Returns

the HardFork object

Definition at line 4847 of file blockchain.cpp.

{
  return m_hardfork->get_state();
}

Here is the caller graph for this function:

get_hard_fork_version()

uint8_t cryptonote::Blockchain::get_hard_fork_version ( uint64_t height ) const

inline

returns the actual hardfork version for a given block height

Parameters

height

the height for which to check version info

Returns

the version

Definition at line 858 of file blockchain.h.

{ return m_hardfork->get(height); }

Here is the caller graph for this function:

get_hard_fork_voting_info()

bool Blockchain::get_hard_fork_voting_info	(	uint8_t	version,
		uint32_t &	window,
		uint32_t &	votes,
		uint32_t &	threshold,
		uint64_t &	earliest_height,
		uint8_t &	voting ) const

get information about hardfork voting for a version

Parameters

version	the version in question
window	the size of the voting window
votes	the number of votes to enable <version>
threshold	the number of votes required to enable <version>
earliest_height	the earliest height at which <version> is allowed
voting	which version this node is voting for/using

Returns

whether the version queried is enabled

Definition at line 4885 of file blockchain.cpp.

{
  return m_hardfork->get_voting_info(version, window, votes, threshold, earliest_height, voting);
}

Here is the caller graph for this function:

get_ideal_hard_fork_version() [1/2]

uint8_t cryptonote::Blockchain::get_ideal_hard_fork_version ( ) const

inline

returns the newest hardfork version known to the blockchain

Returns

the version

Definition at line 832 of file blockchain.h.

{ return m_hardfork->get_ideal_version(); }

Here is the caller graph for this function:

get_ideal_hard_fork_version() [2/2]

uint8_t cryptonote::Blockchain::get_ideal_hard_fork_version ( uint64_t height ) const

inline

returns the newest hardfork version voted to be enabled as of a certain height

Parameters

height

the height for which to check version info

Returns

the version

Definition at line 849 of file blockchain.h.

{ return m_hardfork->get_ideal_version(height); }

get_last_block_timestamps()

std::vector< time_t > Blockchain::get_last_block_timestamps

(

unsigned int

blocks

)

const

returns the timestamps of the last N blocks

Definition at line 1084 of file blockchain.cpp.

{
  uint64_t height = m_db->height();
  if (blocks > height)
    blocks = height;
  std::vector<time_t> timestamps(blocks);
  while (blocks--)
    timestamps[blocks] = m_db->get_block_timestamp(height - blocks - 1);
  return timestamps;
}

get_mempool_tx_livetime()

uint32_t Blockchain::get_mempool_tx_livetime

(

)

const

Definition at line 4808 of file blockchain.cpp.

{
  if(get_hard_fork_version(get_current_blockchain_height()) >= 6)
  {
    return CRYPTONOTE_MEMPOOL_TX_LIVETIME_V6;
  }
  return CRYPTONOTE_MEMPOOL_TX_LIVETIME;
}

Here is the call graph for this function:

get_nettype()

network_type cryptonote::Blockchain::get_nettype ( ) const

inline

get blockchain nettype

Definition at line 1073 of file blockchain.h.

{ return m_nettype; };

Here is the caller graph for this function:

get_next_hard_fork_version()

uint8_t cryptonote::Blockchain::get_next_hard_fork_version ( ) const

inline

returns the next hardfork version

Returns

the version

Definition at line 839 of file blockchain.h.

{ return m_hardfork->get_next_version(); }

Here is the caller graph for this function:

get_next_long_term_block_weight()

uint64_t Blockchain::get_next_long_term_block_weight

(

uint64_t

block_weight

)

const

gets the long term block weight for a new block

Returns

the long term block weight

Definition at line 4100 of file blockchain.cpp.

{
  PERF_TIMER(get_next_long_term_block_weight);
 
  const uint64_t db_height = m_db->height();
  const uint64_t nblocks = std::min<uint64_t>(m_long_term_block_weights_window, db_height);
 
  const uint8_t hf_version = get_current_hard_fork_version();
  if (hf_version < HF_VERSION_LONG_TERM_BLOCK_WEIGHT)
    return block_weight;
 
  uint64_t long_term_median = get_long_term_block_weight_median(db_height - nblocks, nblocks);
  uint64_t long_term_effective_median_block_weight = std::max<uint64_t>(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5, long_term_median);
 
  uint64_t short_term_constraint = long_term_effective_median_block_weight + long_term_effective_median_block_weight * 2 / 5;
  uint64_t long_term_block_weight = std::min<uint64_t>(block_weight, short_term_constraint);
 
  return long_term_block_weight;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_num_mature_outputs()

uint64_t Blockchain::get_num_mature_outputs

(

uint64_t

amount

)

const

get number of outputs of an amount past the minimum spendable age

Parameters

amount

the output amount

Returns

the number of mature outputs

Definition at line 2215 of file blockchain.cpp.

{
  uint64_t num_outs = m_db->get_num_outputs(amount);
  // ensure we don't include outputs that aren't yet eligible to be used
  // outpouts are sorted by height
  const uint64_t blockchain_height = m_db->height();
  while (num_outs > 0)
  {
    const tx_out_index toi = m_db->get_output_tx_and_index(amount, num_outs - 1);
    const uint64_t height = m_db->get_tx_block_height(toi.first);
    if (height + (get_current_hard_fork_version() > 7 ? ETN_DEFAULT_TX_SPENDABLE_AGE_V8 : CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE) <= blockchain_height)
      break;
    --num_outs;
  }
 
  return num_outs;
}

Here is the call graph for this function:

get_output_distribution()

bool Blockchain::get_output_distribution	(	uint64_t	amount,
		uint64_t	from_height,
		uint64_t	to_height,
		uint64_t &	start_height,
		std::vector< uint64_t > &	distribution,
		uint64_t &	base ) const

gets per block distribution of outputs of a given amount

Parameters

amount	the amount to get a ditribution for
from_height	the height before which we do not care about the data
to_height	the height after which we do not care about the data
return-by-reference	start_height the height of the first rct output
return-by-reference	distribution the start offset of the first rct output in this block (same as previous if none)
return-by-reference	base how many outputs of that amount are before the stated distribution

Definition at line 2293 of file blockchain.cpp.

{
  // rct outputs don't exist before v4
  if (amount == 0)
  {
    switch (m_nettype)
    {
      case STAGENET: start_height = stagenet_hard_forks[3].height; break;
      case TESTNET: start_height = testnet_hard_forks[3].height; break;
      case MAINNET: start_height = mainnet_hard_forks[3].height; break;
      case FAKECHAIN: start_height = 0; break;
      default: return false;
    }
  }
  else
    start_height = 0;
  base = 0;
 
  if (to_height > 0 && to_height < from_height)
    return false;
 
  const uint64_t real_start_height = start_height;
  if (from_height > start_height)
    start_height = from_height;
 
  distribution.clear();
  uint64_t db_height = m_db->height();
  if (db_height == 0)
    return false;
  if (start_height >= db_height || to_height >= db_height)
    return false;
  if (amount == 0)
  {
    std::vector<uint64_t> heights;
    heights.reserve(to_height + 1 - start_height);
    uint64_t real_start_height = start_height > 0 ? start_height-1 : start_height;
    for (uint64_t h = real_start_height; h <= to_height; ++h)
      heights.push_back(h);
    distribution = m_db->get_block_cumulative_rct_outputs(heights);
    if (start_height > 0)
    {
      base = distribution[0];
      distribution.erase(distribution.begin());
    }
    return true;
  }
  else
  {
    return m_db->get_output_distribution(amount, start_height, to_height, distribution, base);
  }
}

get_output_histogram()

std::map< uint64_t, std::tuple< uint64_t, uint64_t, uint64_t > > Blockchain::get_output_histogram	(	const std::vector< uint64_t > &	amounts,
		bool	unlocked,
		uint64_t	recent_cutoff,
		uint64_t	min_count = 0 ) const

return a histogram of outputs on the blockchain

Parameters

amounts	optional set of amounts to lookup
unlocked	whether to restrict instances to unlocked ones
recent_cutoff	timestamp to consider outputs as recent
min_count	return only amounts with at least that many instances

Returns

a set of amount/instances

Definition at line 4895 of file blockchain.cpp.

{
  return m_db->get_output_histogram(amounts, unlocked, recent_cutoff, min_count);
}

get_output_key()

crypto::public_key Blockchain::get_output_key	(	uint64_t	amount,
		uint64_t	global_index ) const

get the public key for an output

Parameters

amount	the output amount
global_index	the output amount-global index

Returns

the public key

Definition at line 2233 of file blockchain.cpp.

{
  output_data_t data = m_db->get_output_key(amount, global_index);
  return data.pubkey;
}

get_output_key_mask_unlocked()

void Blockchain::get_output_key_mask_unlocked	(	const uint64_t &	amount,
		const uint64_t &	index,
		crypto::public_key &	key,
		rct::key &	mask,
		bool &	unlocked ) const

gets an output's key and unlocked state

Parameters

amount	in - the output amount
index	in - the output global amount index
mask	out - the output's RingCT mask
key	out - the output's key
unlocked	out - the output's unlocked state

Definition at line 2284 of file blockchain.cpp.

{
  const auto o_data = m_db->get_output_key(amount, index);
  key = o_data.pubkey;
  mask = o_data.commitment;
  tx_out_index toi = m_db->get_output_tx_and_index(amount, index);
  unlocked = is_tx_spendtime_unlocked(m_db->get_tx_unlock_time(toi.first));
}

get_outs()

bool Blockchain::get_outs	(	const COMMAND_RPC_GET_OUTPUTS_BIN::request &	req,
		COMMAND_RPC_GET_OUTPUTS_BIN::response &	res ) const

gets specific outputs to mix with

This function takes an RPC request for outputs to mix with and creates an RPC response with the resultant output indices.

Outputs to mix with are specified in the request.

Parameters

req	the outputs to return
res	return-by-reference the resultant output indices and keys

Returns

true

Definition at line 2240 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  res.outs.clear();
  res.outs.reserve(req.outputs.size());
 
  std::vector<cryptonote::output_data_t> data;
  try
  {
    std::vector<uint64_t> amounts, offsets;
    amounts.reserve(req.outputs.size());
    offsets.reserve(req.outputs.size());
    for (const auto &i: req.outputs)
    {
      amounts.push_back(i.amount);
      offsets.push_back(i.index);
    }
    m_db->get_output_key(epee::span<const uint64_t>(amounts.data(), amounts.size()), offsets, data);
    if (data.size() != req.outputs.size())
    {
      MERROR("Unexpected output data size: expected " << req.outputs.size() << ", got " << data.size());
      return false;
    }
    for (const auto &t: data)
      res.outs.push_back({t.pubkey, t.commitment, is_tx_spendtime_unlocked(t.unlock_time), t.height, crypto::null_hash});
 
    if (req.get_txid)
    {
      for (size_t i = 0; i < req.outputs.size(); ++i)
      {
        tx_out_index toi = m_db->get_output_tx_and_index(req.outputs[i].amount, req.outputs[i].index);
        res.outs[i].txid = toi.first;
      }
    }
  }
  catch (const std::exception &e)
  {
    return false;
  }
  return true;
}

get_short_chain_history()

bool Blockchain::get_short_chain_history

(

std::list< crypto::hash > &

ids

)

const

gets the hashes for a subset of the blockchain

puts into list <ids> a list of hashes representing certain blocks from the blockchain in reverse chronological order

the blocks chosen, at the time of this writing, are: the most recent 11 powers of 2 less recent from there, so 13, 17, 25, etc...

Parameters

ids	return-by-reference list to put the resulting hashes in

Returns

true

Definition at line 859 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  uint64_t i = 0;
  uint64_t current_multiplier = 1;
  uint64_t sz = m_db->height();
 
  if(!sz)
    return true;
 
  db_rtxn_guard rtxn_guard(m_db);
  bool genesis_included = false;
  uint64_t current_back_offset = 1;
  while(current_back_offset < sz)
  {
    ids.push_back(m_db->get_block_hash_from_height(sz - current_back_offset));
 
    if(sz-current_back_offset == 0)
    {
      genesis_included = true;
    }
    if(i < 10)
    {
      ++current_back_offset;
    }
    else
    {
      current_multiplier *= 2;
      current_back_offset += current_multiplier;
    }
    ++i;
  }
 
  if (!genesis_included)
  {
    ids.push_back(m_db->get_block_hash_from_height(0));
  }
 
  return true;
}

get_split_transactions_blobs()

template<class t_ids_container, class t_tx_container, class t_missed_container>

template bool cryptonote::Blockchain::get_split_transactions_blobs	(	const t_ids_container &	txs_ids,
		t_tx_container &	txs,
		t_missed_container &	missed_txs ) const

Definition at line 2500 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  reserve_container(txs, txs_ids.size());
  for (const auto& tx_hash : txs_ids)
  {
    try
    {
      cryptonote::blobdata tx;
      if (m_db->get_pruned_tx_blob(tx_hash, tx))
      {
        txs.push_back(std::make_tuple(tx_hash, std::move(tx), crypto::null_hash, cryptonote::blobdata()));
        if (!is_v1_tx(std::get<1>(txs.back())) && !m_db->get_prunable_tx_hash(tx_hash, std::get<2>(txs.back())))
        {
          MERROR("Prunable data hash not found for " << tx_hash);
          return false;
        }
        if (!m_db->get_prunable_tx_blob(tx_hash, std::get<3>(txs.back())))
          std::get<3>(txs.back()).clear();
      }
      else
        missed_txs.push_back(tx_hash);
    }
    catch (const std::exception& e)
    {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

get_tail_id() [1/2]

crypto::hash Blockchain::get_tail_id

(

)

const

get the hash of the most recent block on the blockchain

Returns

the hash

Definition at line 837 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  return m_db->top_block_hash();
}

Here is the caller graph for this function:

get_tail_id() [2/2]

crypto::hash Blockchain::get_tail_id

(

uint64_t &

height

)

const

get the height and hash of the most recent block on the blockchain

Parameters

height

return-by-reference variable to store the height in

Returns

the hash

Definition at line 830 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  return m_db->top_block_hash(&height);
}

get_total_transactions()

size_t Blockchain::get_total_transactions

(

)

const

gets the total number of transactions on the main chain

Returns

the number of transactions on the main chain

Definition at line 2721 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  return m_db->get_tx_count();
}

get_transactions()

template<class t_ids_container, class t_tx_container, class t_missed_container>

template bool cryptonote::Blockchain::get_transactions	(	const t_ids_container &	txs_ids,
		t_tx_container &	txs,
		t_missed_container &	missed_txs ) const

Definition at line 2534 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  reserve_container(txs, txs_ids.size());
  for (const auto& tx_hash : txs_ids)
  {
    try
    {
      cryptonote::blobdata tx;
      if (m_db->get_tx_blob(tx_hash, tx))
      {
        txs.push_back(transaction());
        if (!parse_and_validate_tx_from_blob(tx, txs.back()))
        {
          LOG_ERROR("Invalid transaction");
          return false;
        }
      }
      else
        missed_txs.push_back(tx_hash);
    }
    catch (const std::exception& e)
    {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_transactions_blobs() [1/2]

template<class t_ids_container, class t_tx_container, class t_missed_container>

bool cryptonote::Blockchain::get_transactions_blobs	(	const t_ids_container &	txs_ids,
		t_tx_container &	txs,
		t_missed_container &	missed_txs,
		bool	pruned ) const

Definition at line 2462 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  reserve_container(txs, txs_ids.size());
  for (const auto& tx_hash : txs_ids)
  {
    try
    {
      cryptonote::blobdata tx;
      if (pruned && m_db->get_pruned_tx_blob(tx_hash, tx))
        txs.push_back(std::move(tx));
      else if (!pruned && m_db->get_tx_blob(tx_hash, tx))
        txs.push_back(std::move(tx));
      else
        missed_txs.push_back(tx_hash);
    }
    catch (const std::exception& e)
    {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

get_transactions_blobs() [2/2]

template<class t_ids_container, class t_tx_container, class t_missed_container>

bool cryptonote::Blockchain::get_transactions_blobs	(	const t_ids_container &	txs_ids,
		t_tx_container &	txs,
		t_missed_container &	missed_txs,
		bool	pruned = false ) const

gets transactions based on a list of transaction hashes

Template Parameters

t_ids_container	a standard-iterable container
t_tx_container	a standard-iterable container
t_missed_container	a standard-iterable container

Parameters

txs_ids	a container of hashes for which to get the corresponding transactions
txs	return-by-reference a container to store result transactions in
missed_txs	return-by-reference a container to store missed transactions in
pruned	whether to return full or pruned blobs

Returns

false if an unexpected exception occurs, else true

Here is the caller graph for this function:

get_tx_outputs_gindexs() [1/2]

bool Blockchain::get_tx_outputs_gindexs	(	const crypto::hash &	tx_id,
		size_t	n_txes,
		std::vector< std::vector< uint64_t > > &	indexs ) const

Definition at line 2801 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  uint64_t tx_index;
  if (!m_db->tx_exists(tx_id, tx_index))
  {
    MERROR_VER("get_tx_outputs_gindexs failed to find transaction with id = " << tx_id);
    return false;
  }
 
  //no output indexes for tx.version >= 2 (public tx)
  if (m_db->get_tx(tx_id).version >= 2)
    return true;
 
  indexs = m_db->get_tx_amount_output_indices(tx_index, n_txes);
  CHECK_AND_ASSERT_MES(n_txes == indexs.size(), false, "Wrong indexs size");
 
  return true;
}

get_tx_outputs_gindexs() [2/2]

bool Blockchain::get_tx_outputs_gindexs	(	const crypto::hash &	tx_id,
		std::vector< uint64_t > &	indexs ) const

gets the global indices for outputs from a given transaction

This function gets the global indices for all outputs belonging to a specific transaction.

Parameters

tx_id	the hash of the transaction to fetch indices for
indexs	return-by-reference the global indices for the transaction's outputs
n_txes	how many txes in a row to get results for

Returns

false if the transaction does not exist, or if no indices are found, otherwise true

Definition at line 2822 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  uint64_t tx_index;
  if (!m_db->tx_exists(tx_id, tx_index))
  {
    MERROR_VER("get_tx_outputs_gindexs failed to find transaction with id = " << tx_id);
    return false;
  }
 
  //no output indexes for tx.version >= 2 (public tx)
  if (m_db->get_tx(tx_id).version >= 2)
    return true;
 
  std::vector<std::vector<uint64_t>> indices = m_db->get_tx_amount_output_indices(tx_index, 1);
  CHECK_AND_ASSERT_MES(indices.size() == 1, false, "Wrong indices size");
  indexs = indices.front();
  return true;
}

get_txpool_tx_blob() [1/2]

cryptonote::blobdata Blockchain::get_txpool_tx_blob

(

const crypto::hash &

txid

)

const

Definition at line 4798 of file blockchain.cpp.

{
  return m_db->get_txpool_tx_blob(txid);
}

get_txpool_tx_blob() [2/2]

bool Blockchain::get_txpool_tx_blob	(	const crypto::hash &	txid,
		cryptonote::blobdata &	bd ) const

Definition at line 4793 of file blockchain.cpp.

{
  return m_db->get_txpool_tx_blob(txid, bd);
}

get_txpool_tx_count()

uint64_t Blockchain::get_txpool_tx_count

(

bool

include_unrelayed_txes = true

)

const

Definition at line 4783 of file blockchain.cpp.

{
  return m_db->get_txpool_tx_count(include_unrelayed_txes);
}

get_txpool_tx_meta()

bool Blockchain::get_txpool_tx_meta	(	const crypto::hash &	txid,
		txpool_tx_meta_t &	meta ) const

Definition at line 4788 of file blockchain.cpp.

{
  return m_db->get_txpool_tx_meta(txid, meta);
}

get_validator_by_height()

electroneum::basic::Validator Blockchain::get_validator_by_height

(

uint64_t

height

)

Definition at line 5085 of file blockchain.cpp.

                                                                             {
 
  block blk;
  get_block_by_hash(get_block_id_by_height(height), blk);
 
  std::string signatory = std::string(blk.signatory.begin(), blk.signatory.end());
  return m_validators->getValidatorByKey(boost::algorithm::hex(signatory));
 
}

Here is the call graph for this function:

handle_get_objects()

bool Blockchain::handle_get_objects	(	NOTIFY_REQUEST_GET_OBJECTS::request &	arg,
		NOTIFY_RESPONSE_GET_OBJECTS::request &	rsp )

retrieves a set of blocks and their transactions, and possibly other transactions

the request object encapsulates a list of block hashes and a (possibly empty) list of transaction hashes. for each block hash, the block is fetched along with all of that block's transactions. Any transactions requested separately are fetched afterwards.

Parameters

arg	the request
rsp	return-by-reference the response to fill in

Returns

true unless any blocks or transactions are missing

Definition at line 2146 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  db_rtxn_guard rtxn_guard (m_db);
  rsp.current_blockchain_height = get_current_blockchain_height();
  std::vector<std::pair<cryptonote::blobdata,block>> blocks;
  get_blocks(arg.blocks, blocks, rsp.missed_ids);
 
  for (auto& bl: blocks)
  {
    std::vector<crypto::hash> missed_tx_ids;
 
    rsp.blocks.push_back(block_complete_entry());
    block_complete_entry& e = rsp.blocks.back();
 
    // FIXME: s/rsp.missed_ids/missed_tx_id/ ?  Seems like rsp.missed_ids
    //        is for missed blocks, not missed transactions as well.
    get_transactions_blobs(bl.second.tx_hashes, e.txs, missed_tx_ids);
 
    if (missed_tx_ids.size() != 0)
    {
      // do not display an error if the peer asked for an unpruned block which we are not meant to have
      if (tools::has_unpruned_block(get_block_height(bl.second), get_current_blockchain_height(), get_blockchain_pruning_seed()))
      {
        LOG_ERROR("Error retrieving blocks, missed " << missed_tx_ids.size()
            << " transactions for block with hash: " << get_block_hash(bl.second)
            << std::endl
        );
      }
 
      // append missed transaction hashes to response missed_ids field,
      // as done below if any standalone transactions were requested
      // and missed.
      rsp.missed_ids.insert(rsp.missed_ids.end(), missed_tx_ids.begin(), missed_tx_ids.end());
      return false;
    }
 
    //pack block
    e.block = std::move(bl.first);
  }
  //get and pack other transactions, if needed
  get_transactions_blobs(arg.txs, rsp.txs, rsp.missed_ids);
 
  return true;
}

Here is the call graph for this function:

have_block()

bool Blockchain::have_block

(

const crypto::hash &

id

)

const

checks if a block is known about with a given hash

This function checks the main chain, alternate chains, and invalid blocks for a block with the given hash

Parameters

id	the hash to search for

Returns

true if the block is known, else false

Definition at line 2688 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  if(m_db->block_exists(id))
  {
    LOG_PRINT_L2("block " << id << " found in main chain");
    return true;
  }
 
  if(m_alternative_chains.count(id))
  {
    LOG_PRINT_L2("block " << id << " found in m_alternative_chains");
    return true;
  }
 
  if(m_invalid_blocks.count(id))
  {
    LOG_PRINT_L2("block " << id << " found in m_invalid_blocks");
    return true;
  }
 
  return false;
}

Here is the caller graph for this function:

have_tx()

bool Blockchain::have_tx

(

const crypto::hash &

id

)

const

search the blockchain for a transaction by hash

Parameters

id	the hash to search for

Returns

true if the tx exists, else false

Definition at line 167 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  return m_db->tx_exists(id);
}

have_tx_keyimg_as_spent()

bool Blockchain::have_tx_keyimg_as_spent

(

const crypto::key_image &

key_im

)

const

check if a key image is already spent on the blockchain

Whenever a transaction output is used as an input for another transaction (a true input, not just one of a mixing set), a key image is generated and stored in the transaction in order to prevent double spending. If this key image is seen again, the transaction using it is rejected.

Parameters

key_im

the key image to search for

Returns

true if the key image is already spent in the blockchain, else false

Definition at line 177 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // WARNING: this function does not take m_blockchain_lock, and thus should only call read only
  // m_db functions which do not depend on one another (ie, no getheight + gethash(height-1), as
  // well as not accessing class members, even read only (ie, m_invalid_blocks). The caller must
  // lock if it is otherwise needed.
  return  m_db->has_key_image(key_im);
}

Here is the caller graph for this function:

init() [1/2]

bool Blockchain::init	(	BlockchainDB *	db,
		const network_type	nettype = MAINNET,
		bool	offline = false,
		const cryptonote::test_options *	test_options = NULL,
		difficulty_type	fixed_difficulty = 0,
		const GetCheckpointsCallback &	get_checkpoints = nullptr,
		bool	ignore_bsig = false,
		bool	fallback_to_pow = false )

Initialize the Blockchain state.

Parameters

db	a pointer to the backing store to use for the blockchain
nettype	network type
offline	true if running offline, else false
test_options	test parameters
fixed_difficulty	fixed difficulty for testing purposes; 0 means disabled
get_checkpoints	if set, will be called to get checkpoints data

Returns

true on success, false if any initialization steps fail

Definition at line 334 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
 
  CHECK_AND_ASSERT_MES(nettype != FAKECHAIN || test_options, false, "fake chain network type used without options");
 
  CRITICAL_REGION_LOCAL(m_tx_pool);
  CRITICAL_REGION_LOCAL1(m_blockchain_lock);
 
  if (db == nullptr)
  {
    LOG_ERROR("Attempted to init Blockchain with null DB");
    return false;
  }
  if (!db->is_open())
  {
    LOG_ERROR("Attempted to init Blockchain with unopened DB");
    delete db;
    return false;
  }
 
  m_db = db;
 
  m_nettype = test_options != NULL ? FAKECHAIN : nettype;
  m_offline = offline;
  m_fixed_difficulty = fixed_difficulty;
  m_ignore_bsig = ignore_bsig;
  m_fallback_to_pow = fallback_to_pow;
  if (m_hardfork == nullptr)
  {
    if (m_nettype ==  FAKECHAIN || m_nettype == STAGENET)
      m_hardfork = new HardFork(*db, 1, 0);
    else if (m_nettype == TESTNET)
      m_hardfork = new HardFork(*db, 1, testnet_hard_fork_version_1_till);
    else
      m_hardfork = new HardFork(*db, 1, mainnet_hard_fork_version_1_till);
  }
  if (m_nettype == FAKECHAIN)
  {
    for (size_t n = 0; test_options->hard_forks[n].first; ++n)
      m_hardfork->add_fork(test_options->hard_forks[n].first, test_options->hard_forks[n].second, 0, n + 1);
  }
  else if (m_nettype == TESTNET)
  {
    for (size_t n = 0; n < sizeof(testnet_hard_forks) / sizeof(testnet_hard_forks[0]); ++n)
      m_hardfork->add_fork(testnet_hard_forks[n].version, testnet_hard_forks[n].height, testnet_hard_forks[n].threshold, testnet_hard_forks[n].time);
  }
  else if (m_nettype == STAGENET)
  {
    for (size_t n = 0; n < sizeof(stagenet_hard_forks) / sizeof(stagenet_hard_forks[0]); ++n)
      m_hardfork->add_fork(stagenet_hard_forks[n].version, stagenet_hard_forks[n].height, stagenet_hard_forks[n].threshold, stagenet_hard_forks[n].time);
  }
  else
  {
    for (size_t n = 0; n < sizeof(mainnet_hard_forks) / sizeof(mainnet_hard_forks[0]); ++n)
      m_hardfork->add_fork(mainnet_hard_forks[n].version, mainnet_hard_forks[n].height, mainnet_hard_forks[n].threshold, mainnet_hard_forks[n].time);
  }
  m_hardfork->init();
 
  m_db->set_hard_fork(m_hardfork);
 
  // if the blockchain is new, add the genesis block
  // this feels kinda kludgy to do it this way, but can be looked at later.
  // TODO: add function to create and store genesis block,
  //       taking testnet into account
  if(!m_db->height())
  {
    MINFO("Blockchain not loaded, generating genesis block.");
    block bl;
    block_verification_context bvc = boost::value_initialized<block_verification_context>();
    generate_genesis_block(bl, get_config(m_nettype).GENESIS_TX, get_config(m_nettype).GENESIS_NONCE);
    db_wtxn_guard wtxn_guard(m_db);
    add_new_block(bl, bvc);
    CHECK_AND_ASSERT_MES(!bvc.m_verification_failed, false, "Failed to add genesis block to blockchain");
  }
  // TODO: if blockchain load successful, verify blockchain against both
  //       hard-coded and runtime-loaded (and enforced) checkpoints.
  else
  {
  }
 
  if (m_nettype != FAKECHAIN)
  {
    m_db->set_batch_transactions(true);
  }
 
  db_rtxn_guard rtxn_guard(m_db);
 
  // check how far behind we are
  uint64_t top_block_timestamp = m_db->get_top_block_timestamp();
  uint64_t timestamp_diff = time(NULL) - top_block_timestamp;
 
  // genesis block has no timestamp, could probably change it to have timestamp of 1397818133...
  if(!top_block_timestamp)
    timestamp_diff = time(NULL) - 1397818133;
 
  // create general purpose async service queue
 
  m_async_work_idle = std::unique_ptr < boost::asio::io_service::work > (new boost::asio::io_service::work(m_async_service));
  // we only need 1
  m_async_pool.create_thread(boost::bind(&boost::asio::io_service::run, &m_async_service));
 
#if defined(PER_BLOCK_CHECKPOINT)
  if (m_nettype != FAKECHAIN)
    load_compiled_in_block_hashes(get_checkpoints);
#endif
 
  MINFO("Blockchain initialized. last block: " << m_db->height() - 1 << ", " << epee::misc_utils::get_time_interval_string(timestamp_diff) << " time ago, current difficulty: " << get_difficulty_for_next_block());
 
  rtxn_guard.stop();
 
  uint64_t num_popped_blocks = 0;
  while (!m_db->is_read_only())
  {
    uint64_t top_height;
    const crypto::hash top_id = m_db->top_block_hash(&top_height);
    const block top_block = m_db->get_top_block();
    const uint8_t ideal_hf_version = get_ideal_hard_fork_version(top_height);
    if (ideal_hf_version <= 1 || ideal_hf_version == top_block.major_version)
    {
      if (num_popped_blocks > 0)
        MGINFO("Initial popping done, top block: " << top_id << ", top height: " << top_height << ", block version: " << (uint64_t)top_block.major_version);
      break;
    }
    else
    {
      if (num_popped_blocks == 0)
        MGINFO("Current top block " << top_id << " at height " << top_height << " has version " << (uint64_t)top_block.major_version << " which disagrees with the ideal version " << (uint64_t)ideal_hf_version);
      if (num_popped_blocks % 100 == 0)
        MGINFO("Popping blocks... " << top_height);
      ++num_popped_blocks;
      block popped_block;
      std::vector<transaction> popped_txs;
      try
      {
        m_db->pop_block(popped_block, popped_txs);
      }
      // anything that could cause this to throw is likely catastrophic,
      // so we re-throw
      catch (const std::exception& e)
      {
        MERROR("Error popping block from blockchain: " << e.what());
        throw;
      }
      catch (...)
      {
        MERROR("Error popping block from blockchain, throwing!");
        throw;
      }
    }
  }
  
  if (num_popped_blocks > 0)
  {
    m_timestamps_and_difficulties_height = 0;
    m_hardfork->reorganize_from_chain_height(get_current_blockchain_height());
    uint64_t top_block_height;
    crypto::hash top_block_hash = get_tail_id(top_block_height);
    m_tx_pool.on_blockchain_dec(top_block_height, top_block_hash);
  }
 
  if (test_options && test_options->long_term_block_weight_window)
  {
    m_long_term_block_weights_window = test_options->long_term_block_weight_window;
    m_long_term_block_weights_cache_rolling_median = epee::misc_utils::rolling_median_t<uint64_t>(m_long_term_block_weights_window);
  }
 
  {
    db_txn_guard txn_guard(m_db, m_db->is_read_only());
    if (!update_next_cumulative_weight_limit())
      return false;
  }
 
  {
    if(!m_db->is_read_only())
    {
      uint64_t top_height;
      m_db->top_block_hash(&top_height);
 
      if(top_height >= 1175315)
      {
        block b = m_db->get_block_from_height(1175315);
        const auto &txout = boost::get<txout_to_key_public>(b.miner_tx.vout[0].target);
        std::vector<cryptonote::address_outputs> addr_outs = m_db->get_addr_output_all(addKeys(txout.address.m_view_public_key, txout.address.m_spend_public_key));
 
        if(addr_outs.empty()) {
          MGINFO("Recomputing address_outputs database...");
          m_db->top_block_hash(&top_height);
          uint64_t diff = top_height - 1175200;
          for(auto i = 0; i < diff; i++) {
            block popped_block;
            std::vector<transaction> popped_txs;
            try
            {
              m_db->pop_block(popped_block, popped_txs);
            }
            catch (const std::exception& e)
            {
              MERROR("Error popping block from blockchain: " << e.what());
              throw;
            }
            catch (...)
            {
              MERROR("Error popping block from blockchain, throwing!");
              throw;
            }
          }
          if (diff > 0)
          {
            m_hardfork->reorganize_from_chain_height(get_current_blockchain_height());
            uint64_t top_block_height;
            crypto::hash top_block_hash = get_tail_id(top_block_height);
            m_tx_pool.on_blockchain_dec(top_block_height, top_block_hash);
          }
          MGINFO("Address_outputs database recomputed OK");
        }
      }
    }
  }
 
    // GO BACK AND POPULATE A DATABASE OF KEY: COMBINED KEY , VALUE: TX INPUT
    {
        db_txn_guard txn_guard(m_db, m_db->is_read_only());
        if(!m_db->is_read_only())
        {
            uint64_t top_height;
            m_db->top_block_hash(&top_height);
            uint64_t private_to_public_fork_height = m_nettype == MAINNET ? 1175315 : 1086402;
            if(top_height >= private_to_public_fork_height)
            {
                block b = m_db->get_block_from_height(private_to_public_fork_height);
                const auto &txout = boost::get<txout_to_key_public>(b.miner_tx.vout[0].target);
                std::vector<cryptonote::address_txs> addr_txs = m_db->get_addr_tx_all(addKeys(txout.address.m_view_public_key, txout.address.m_spend_public_key));
                if(addr_txs.empty()) {
                    MGINFO("Populating addr tx database...");
                    m_db->top_block_hash(&top_height);
                    // begin at the private to public fork block and store the data in addr_tx db one block at a time
                    uint64_t working_height = private_to_public_fork_height;
                    while (working_height <= top_height) {
                        block working_block = m_db->get_block_from_height(working_height);
                        //deal with miner tx first
                        for( auto vout: working_block.miner_tx.vout){ // all vouts are of type txout to key public
                              const auto &txout = boost::get<txout_to_key_public>(vout.target);
                              m_db->add_addr_tx(get_transaction_hash(working_block.miner_tx), addKeys(txout.address.m_view_public_key, txout.address.m_spend_public_key));
 
                        }
                        //deal with all other tx
                        std::vector<transaction> transactions = m_db->get_tx_list(working_block.tx_hashes);
                        for (auto tx : transactions){
                            auto hash = get_transaction_hash(tx);
                            std::unordered_set<crypto::public_key> addr_tx_addresses;
                            for (size_t i = 0; i < tx.vin.size(); i++){
                                if (tx.vin[i].type() == typeid(txin_to_key_public))
                                {
                                    const auto &txin = boost::get<txin_to_key_public>(tx.vin[i]);
                                    transaction parent_tx = m_db->get_tx(txin.tx_hash);
                                    const auto &txout = boost::get<txout_to_key_public>(parent_tx.vout[txin.relative_offset].target); //previous tx out that this tx in references
                                    crypto::public_key combined_key = addKeys(txout.address.m_view_public_key, txout.address.m_spend_public_key);
                                    if(addr_tx_addresses.find(combined_key) == addr_tx_addresses.end()){ //if addr hasn't been used for another input yet, add the unique addr tx record for this address
                                        m_db->add_addr_tx(hash, combined_key);
                                        addr_tx_addresses.emplace(combined_key);
                                    }
                                }
                            }
                            for(size_t i = 0; i < tx.vout.size(); i++){ // all vouts are of type txout to key public
                                const auto &txout = boost::get<txout_to_key_public>(tx.vout[i].target);
                                crypto::public_key combined_key = addKeys(txout.address.m_view_public_key, txout.address.m_spend_public_key);
                                if(addr_tx_addresses.find(combined_key) == addr_tx_addresses.end()){ //if addr hasn't been used for another input yet, add the unique addr tx record for this address
                                    m_db->add_addr_tx(tx.hash, combined_key);
                                    addr_tx_addresses.emplace(combined_key);
                                }
                            }
                        }
                        ++working_height;
                    }
                    MGINFO("Addr_txs database recomputed OK");
                }
 
            }
        }
    
        txn_guard.stop();
    }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init() [2/2]

bool Blockchain::init	(	BlockchainDB *	db,
		HardFork *&	hf,
		const network_type	nettype = MAINNET,
		bool	offline = false )

Initialize the Blockchain state.

Parameters

db	a pointer to the backing store to use for the blockchain
hf	a structure containing hardfork information
nettype	network type
offline	true if running offline, else false

Returns

true on success, false if any initialization steps fail

Definition at line 620 of file blockchain.cpp.

{
  if (hf != nullptr)
    m_hardfork = hf;
  bool res = init(db, nettype, offline, NULL);
  if (hf == nullptr)
    hf = m_hardfork;
  return res;
}

Here is the call graph for this function:

is_within_compiled_block_hash_area() [1/2]

bool cryptonote::Blockchain::is_within_compiled_block_hash_area ( ) const

inline

Definition at line 1016 of file blockchain.h.

{ return is_within_compiled_block_hash_area(m_db->height()); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_within_compiled_block_hash_area() [2/2]

bool Blockchain::is_within_compiled_block_hash_area

(

uint64_t

height

)

const

Definition at line 5022 of file blockchain.cpp.

{
#if defined(PER_BLOCK_CHECKPOINT)
  return height < m_blocks_hash_check.size();
#else
  return false;
#endif
}

key_images_already_spent()

bool Blockchain::key_images_already_spent

(

const transaction &

tx

)

const

check if any key image in a transaction has already been spent

Parameters

tx	the transaction to check

Returns

true if any key image is already spent in the blockchain, else false

Definition at line 2958 of file blockchain.cpp.

{
    LOG_PRINT_L3("Blockchain::" << __func__);
 
    for (const txin_v& in: tx.vin)
    {
      if(in.type() == typeid(txin_to_key))
      {
        const auto &in_to_key = boost::get<txin_to_key>(in);
        if(have_tx_keyimg_as_spent(in_to_key.k_image))
            return true;
      }
    }
 
    return false;
}

Here is the call graph for this function:

lock()

void Blockchain::lock

(

)

Definition at line 5031 of file blockchain.cpp.

{
  m_blockchain_lock.lock();
}

normalize_v7_difficulties()

void Blockchain::normalize_v7_difficulties

(

)

Normalize the cumulative difficulty for V7 blocks, fixing the differing difficulty among nodes.

Definition at line 1098 of file blockchain.cpp.

                                           {
 
  auto height = m_db->height();
  const uint64_t v8height = m_nettype == TESTNET ? 446674 : 589169;
 
  if(height != v8height) {
    return;
  }
 
  const uint64_t v7height = m_nettype == TESTNET ? 215000 : 324500;
  const size_t V7_DIFFICULTY_BLOCKS_COUNT = 735;
  const size_t V7_DIFFICULTY_TARGET = 120;
 
  std::vector<uint64_t> timestamps;
  std::vector<difficulty_type> difficulties;
 
  uint64_t start_height = v7height - V7_DIFFICULTY_BLOCKS_COUNT;
 
  // Populate the timestamps & difficulties vectors with data from 735 blocks prior to V7 fork height (324500)
  for(uint64_t i = 0; start_height + i < v7height; i++) {
    timestamps.push_back(m_db->get_block_timestamp(start_height + i));
    difficulties.push_back(m_db->get_block_cumulative_difficulty(start_height + i));
  }
 
  // Calculate the cumulative difficulty of block 324500 based on the 735 prior blocks' timestamp and difficulty values
  difficulty_type diff = difficulties.back() + next_difficulty(timestamps, difficulties, V7_DIFFICULTY_TARGET, 1);
 
  // Override block's 324500 cumulative difficulty
  m_db->set_block_cumulative_difficulty(v7height, diff);
 
  // Iterate over V7 blocks, starting from 324500 until current block height
  for(uint64_t i = v7height; i < height - 1; i++) {
 
    // Add "324500 + i" timestamp & difficulty into the vectors
    timestamps.push_back(m_db->get_block_timestamp(i));
    difficulties.push_back(m_db->get_block_cumulative_difficulty(i));
 
    // Erase the vector's first position maintaining its 735 size
    timestamps.erase(timestamps.begin());
    difficulties.erase(difficulties.begin());
 
    // Calculate/set the correct cumulative difficulty of block "324500 + i"
    diff = difficulties.back() + next_difficulty(timestamps, difficulties, V7_DIFFICULTY_TARGET, 1);
    m_db->set_block_cumulative_difficulty(i + 1, diff);
  }
 
  m_timestamps.clear();
  m_difficulties.clear();
}

Here is the call graph for this function:

on_new_tx_from_block()

void Blockchain::on_new_tx_from_block

(

const cryptonote::transaction &

tx

)

called when we see a tx originating from a block

Used for handling txes from historical blocks in a fast way

Definition at line 2843 of file blockchain.cpp.

{
#if defined(PER_BLOCK_CHECKPOINT)
  // check if we're doing per-block checkpointing
  if (m_db->height() < m_blocks_hash_check.size())
  {
    TIME_MEASURE_START(a);
    m_blocks_txs_check.push_back(get_transaction_hash(tx));
    TIME_MEASURE_FINISH(a);
    if(m_show_time_stats)
    {
      size_t ring_size = !tx.vin.empty() && tx.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(tx.vin[0]).key_offsets.size() : 0;
      MINFO("HASH: " << "-" << " I/M/O: " << tx.vin.size() << "/" << ring_size << "/" << tx.vout.size() << " H: " << 0 << " chcktx: " << a);
    }
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

output_scan_worker()

void Blockchain::output_scan_worker	(	const uint64_t	amount,
		const std::vector< uint64_t > &	offsets,
		std::vector< output_data_t > &	outputs ) const

get a number of outputs of a specific amount

Parameters

amount	the amount
offsets	the indices (indexed to the amount) of the outputs
outputs	return-by-reference the outputs collected

Definition at line 4396 of file blockchain.cpp.

{
  try
  {
    m_db->get_output_key(epee::span<const uint64_t>(&amount, 1), offsets, outputs, true);
  }
  catch (const std::exception& e)
  {
    MERROR_VER("EXCEPTION: " << e.what());
  }
  catch (...)
  {
 
  }
}

Here is the caller graph for this function:

pop_blocks()

void Blockchain::pop_blocks

(

uint64_t

nblocks

)

removes blocks from the top of the blockchain

Parameters

nblocks

number of blocks to be removed

Definition at line 700 of file blockchain.cpp.

{
  uint64_t i;
  CRITICAL_REGION_LOCAL(m_tx_pool);
  CRITICAL_REGION_LOCAL1(m_blockchain_lock);
 
  bool stop_batch = m_db->batch_start();
 
  try
  {
    const uint64_t blockchain_height = m_db->height();
    if (blockchain_height > 0)
      nblocks = std::min(nblocks, blockchain_height - 1);
    for (i=0; i < nblocks; ++i)
    {
      pop_block_from_blockchain();
    }
  }
  catch (const std::exception& e)
  {
    LOG_ERROR("Error when popping blocks after processing " << i << " blocks: " << e.what());
    if (stop_batch)
      m_db->batch_abort();
    return;
  }
 
  if (stop_batch)
    m_db->batch_stop();
}

prepare_handle_incoming_blocks()

bool Blockchain::prepare_handle_incoming_blocks	(	const std::vector< block_complete_entry > &	blocks_entry,
		std::vector< block > &	blocks )

performs some preprocessing on a group of incoming blocks to speed up verification

Parameters

blocks_entry	a list of incoming blocks
blocks	the parsed blocks

Returns

false on erroneous blocks, else true

Definition at line 4419 of file blockchain.cpp.

{
  MTRACE("Blockchain::" << __func__);
  TIME_MEASURE_START(prepare);
  bool stop_batch;
  uint64_t bytes = 0;
  size_t total_txs = 0;
  blocks.clear();
 
  // Order of locking must be:
  //  m_incoming_tx_lock (optional)
  //  m_tx_pool lock
  //  blockchain lock
  //
  //  Something which takes the blockchain lock may never take the txpool lock
  //  if it has not provably taken the txpool lock earlier
  //
  //  The txpool lock is now taken in prepare_handle_incoming_blocks
  //  and released in cleanup_handle_incoming_blocks. This avoids issues
  //  when something uses the pool, which now uses the blockchain and
  //  needs a batch, since a batch could otherwise be active while the
  //  txpool and blockchain locks were not held
 
  m_tx_pool.lock();
  CRITICAL_REGION_LOCAL1(m_blockchain_lock);
 
  if(blocks_entry.size() == 0)
    return false;
 
  for (const auto &entry : blocks_entry)
  {
    bytes += entry.block.size();
    for (const auto &tx_blob : entry.txs)
    {
      bytes += tx_blob.size();
    }
    total_txs += entry.txs.size();
  }
  m_bytes_to_sync += bytes;
  while (!(stop_batch = m_db->batch_start(blocks_entry.size(), bytes))) {
    m_blockchain_lock.unlock();
    m_tx_pool.unlock();
    epee::misc_utils::sleep_no_w(1000);
    m_tx_pool.lock();
    m_blockchain_lock.lock();
  }
  m_batch_success = true;
 
  const uint64_t height = m_db->height();
  if ((height + blocks_entry.size()) < m_blocks_hash_check.size())
    return true;
 
  bool blocks_exist = false;
  tools::threadpool& tpool = tools::threadpool::getInstance();
  unsigned threads = tpool.get_max_concurrency();
  blocks.resize(blocks_entry.size());
 
  if (1)
  {
    // limit threads, default limit = 4
    if(threads > m_max_prepare_blocks_threads)
      threads = m_max_prepare_blocks_threads;
 
    unsigned int batches = blocks_entry.size() / threads;
    unsigned int extra = blocks_entry.size() % threads;
    MDEBUG("block_batches: " << batches);
    std::vector<std::unordered_map<crypto::hash, crypto::hash>> maps(threads);
    auto it = blocks_entry.begin();
    unsigned blockidx = 0;
 
    const crypto::hash tophash = m_db->top_block_hash();
    for (unsigned i = 0; i < threads; i++)
    {
      for (unsigned int j = 0; j < batches; j++, ++blockidx)
      {
        block &block = blocks[blockidx];
        crypto::hash block_hash;
 
        if (!parse_and_validate_block_from_blob(it->block, block, block_hash))
          return false;
 
        // check first block and skip all blocks if its not chained properly
        if (blockidx == 0)
        {
          if (block.prev_id != tophash)
          {
            MDEBUG("Skipping prepare blocks. New blocks don't belong to chain.");
            blocks.clear();
            return true;
          }
        }
        if (have_block(block_hash))
          blocks_exist = true;
 
        std::advance(it, 1);
      }
    }
 
    for (unsigned i = 0; i < extra && !blocks_exist; i++, blockidx++)
    {
      block &block = blocks[blockidx];
      crypto::hash block_hash;
 
      if (!parse_and_validate_block_from_blob(it->block, block, block_hash))
        return false;
 
      if (have_block(block_hash))
        blocks_exist = true;
 
      std::advance(it, 1);
    }
 
    if (!blocks_exist)
    {
      m_blocks_longhash_table.clear();
      uint64_t thread_height = height;
      tools::threadpool::waiter waiter;
      for (unsigned int i = 0; i < threads; i++)
      {
        unsigned nblocks = batches;
        if (i < extra)
          ++nblocks;
        tpool.submit(&waiter, boost::bind(&Blockchain::block_longhash_worker, this, thread_height, epee::span<const block>(&blocks[thread_height - height], nblocks), std::ref(maps[i])), true);
        thread_height += nblocks;
      }
 
      waiter.wait(&tpool);
 
      if (m_cancel)
         return false;
 
      for (const auto & map : maps)
      {
        m_blocks_longhash_table.insert(map.begin(), map.end());
      }
    }
  }
 
  if (m_cancel)
    return false;
 
  if (blocks_exist)
  {
    MDEBUG("Skipping remainder of prepare blocks. Blocks exist.");
    return true;
  }
 
  m_fake_scan_time = 0;
  m_fake_pow_calc_time = 0;
 
  m_scan_table.clear();
  m_check_txin_table.clear();
 
  TIME_MEASURE_FINISH(prepare);
  m_fake_pow_calc_time = prepare / blocks_entry.size();
 
  if (blocks_entry.size() > 1 && threads > 1 && m_show_time_stats)
    MDEBUG("Prepare blocks took: " << prepare << " ms");
 
  TIME_MEASURE_START(scantable);
 
  // [input] stores all unique amounts found
  std::vector < uint64_t > amounts;
  // [input] stores all absolute_offsets for each amount
  std::map<uint64_t, std::vector<uint64_t>> offset_map;
  // [output] stores all output_data_t for each absolute_offset
  std::map<uint64_t, std::vector<output_data_t>> tx_map;
  std::vector<std::pair<cryptonote::transaction, crypto::hash>> txes(total_txs);
 
#define SCAN_TABLE_QUIT(m) \
        do { \
            MERROR_VER(m) ;\
            m_scan_table.clear(); \
            return false; \
        } while(0); \
 
  // generate sorted tables for all amounts and absolute offsets
  size_t tx_index = 0, block_index = 0;
  for (const auto &entry : blocks_entry)
  {
    if (m_cancel)
      return false;
 
    for (const auto &tx_blob : entry.txs)
    {
      if (tx_index >= txes.size())
        SCAN_TABLE_QUIT("tx_index is out of sync");
      transaction &tx = txes[tx_index].first;
      crypto::hash &tx_prefix_hash = txes[tx_index].second;
      ++tx_index;
 
      if (!parse_and_validate_tx_base_from_blob(tx_blob, tx))
        SCAN_TABLE_QUIT("Could not parse tx from incoming blocks.");
      cryptonote::get_transaction_prefix_hash(tx, tx_prefix_hash);
 
      auto its = m_scan_table.find(tx_prefix_hash);
      if (its != m_scan_table.end())
        SCAN_TABLE_QUIT("Duplicate tx found from incoming blocks.");
 
      m_scan_table.emplace(tx_prefix_hash, std::unordered_map<crypto::key_image, std::vector<output_data_t>>());
      its = m_scan_table.find(tx_prefix_hash);
      assert(its != m_scan_table.end());
 
      if(tx.version <= 2)
      {
        // get all amounts from tx.vin(s)
        for (const auto &txin : tx.vin)
        {
          const txin_to_key &in_to_key = boost::get < txin_to_key > (txin);
 
          // check for duplicate
          auto it = its->second.find(in_to_key.k_image);
          if (it != its->second.end())
            SCAN_TABLE_QUIT("Duplicate key_image found from incoming blocks.");
 
          amounts.push_back(in_to_key.amount);
        }
      }
 
      // sort and remove duplicate amounts from amounts list
      std::sort(amounts.begin(), amounts.end());
      auto last = std::unique(amounts.begin(), amounts.end());
      amounts.erase(last, amounts.end());
 
      // add amount to the offset_map and tx_map
      for (const uint64_t &amount : amounts)
      {
        if (offset_map.find(amount) == offset_map.end())
          offset_map.emplace(amount, std::vector<uint64_t>());
 
        if (tx_map.find(amount) == tx_map.end())
          tx_map.emplace(amount, std::vector<output_data_t>());
      }
 
      if(tx.version <= 2)
      {
        // add new absolute_offsets to offset_map
        for (const auto &txin : tx.vin)
        {
          const txin_to_key &in_to_key = boost::get < txin_to_key > (txin);
          // no need to check for duplicate here.
          auto absolute_offsets = relative_output_offsets_to_absolute(in_to_key.key_offsets);
          for (const auto & offset : absolute_offsets)
            offset_map[in_to_key.amount].push_back(offset);
 
        }
      }
    }
    ++block_index;
  }
 
  // sort and remove duplicate absolute_offsets in offset_map
  for (auto &offsets : offset_map)
  {
    std::sort(offsets.second.begin(), offsets.second.end());
    auto last = std::unique(offsets.second.begin(), offsets.second.end());
    offsets.second.erase(last, offsets.second.end());
  }
 
  // gather all the output keys
  threads = tpool.get_max_concurrency();
  if (!m_db->can_thread_bulk_indices())
    threads = 1;
 
  if (threads > 1 && amounts.size() > 1)
  {
    tools::threadpool::waiter waiter;
 
    for (size_t i = 0; i < amounts.size(); i++)
    {
      uint64_t amount = amounts[i];
      tpool.submit(&waiter, boost::bind(&Blockchain::output_scan_worker, this, amount, std::cref(offset_map[amount]), std::ref(tx_map[amount])), true);
    }
    waiter.wait(&tpool);
  }
  else
  {
    for (size_t i = 0; i < amounts.size(); i++)
    {
      uint64_t amount = amounts[i];
      output_scan_worker(amount, offset_map[amount], tx_map[amount]);
    }
  }
 
  // now generate a table for each tx_prefix and k_image hashes
  tx_index = 0;
  for (const auto &entry : blocks_entry)
  {
    if (m_cancel)
      return false;
 
    for (const auto &tx_blob : entry.txs)
    {
      if (tx_index >= txes.size())
        SCAN_TABLE_QUIT("tx_index is out of sync");
      const transaction &tx = txes[tx_index].first;
      const crypto::hash &tx_prefix_hash = txes[tx_index].second;
      ++tx_index;
 
      auto its = m_scan_table.find(tx_prefix_hash);
      if (its == m_scan_table.end())
        SCAN_TABLE_QUIT("Tx not found on scan table from incoming blocks.");
 
      if(tx.version >= 3) continue;
 
      for (const auto &txin : tx.vin)
      {
        const txin_to_key &in_to_key = boost::get < txin_to_key > (txin);
        auto needed_offsets = relative_output_offsets_to_absolute(in_to_key.key_offsets);
 
        std::vector<output_data_t> outputs;
        for (const uint64_t & offset_needed : needed_offsets)
        {
          size_t pos = 0;
          bool found = false;
 
          for (const uint64_t &offset_found : offset_map[in_to_key.amount])
          {
            if (offset_needed == offset_found)
            {
              found = true;
              break;
            }
 
            ++pos;
          }
 
          if (found && pos < tx_map[in_to_key.amount].size())
            outputs.push_back(tx_map[in_to_key.amount].at(pos));
          else
            break;
        }
 
        its->second.emplace(in_to_key.k_image, outputs);
      }
    }
  }
 
  TIME_MEASURE_FINISH(scantable);
  if (total_txs > 0)
  {
    m_fake_scan_time = scantable / total_txs;
    if(m_show_time_stats)
      MDEBUG("Prepare scantable took: " << scantable << " ms");
  }
 
  return true;
}

Here is the call graph for this function:

prune_blockchain()

bool Blockchain::prune_blockchain

(

uint32_t

pruning_seed = 0

)

Definition at line 4073 of file blockchain.cpp.

{
  m_tx_pool.lock();
  epee::misc_utils::auto_scope_leave_caller unlocker = epee::misc_utils::create_scope_leave_handler([&](){m_tx_pool.unlock();});
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  return m_db->prune_blockchain(pruning_seed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

remove_txpool_tx()

void Blockchain::remove_txpool_tx

(

const crypto::hash &

txid

)

Definition at line 4778 of file blockchain.cpp.

{
  m_db->remove_txpool_tx(txid);
}

reset_and_set_genesis_block()

bool Blockchain::reset_and_set_genesis_block

(

const block &

b

)

clears the blockchain and starts a new one

Parameters

b	the first block in the new chain (the genesis block)

Returns

true on success, else false

Definition at line 812 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
  m_timestamps_and_difficulties_height = 0;
  m_alternative_chains.clear();
  invalidate_block_template_cache();
  m_db->reset();
  m_hardfork->init();
 
  db_wtxn_guard wtxn_guard(m_db);
  block_verification_context bvc = boost::value_initialized<block_verification_context>();
  add_new_block(b, bvc);
  if (!update_next_cumulative_weight_limit())
    return false;
  return bvc.m_added_to_main_chain && !bvc.m_verification_failed;
}

Here is the call graph for this function:

safesyncmode()

void Blockchain::safesyncmode

(

const bool

onoff

)

Put DB in safe sync mode.

Definition at line 4835 of file blockchain.cpp.

{
  /* all of this is no-op'd if the user set a specific
   * --db-sync-mode at startup.
   */
  if (m_db_default_sync)
  {
    m_db->safesyncmode(onoff);
    m_db_sync_mode = onoff ? db_nosync : db_async;
  }
}

set_block_notify()

void cryptonote::Blockchain::set_block_notify ( const std::shared_ptr< tools::Notify > & notify )

inline

sets a block notify object to call for every new block

Parameters

notify

the notify object to call at every new block

Definition at line 785 of file blockchain.h.

{ m_block_notify = notify; }

set_checkpoints()

void cryptonote::Blockchain::set_checkpoints ( checkpoints && chk_pts )

inline

assign a set of blockchain checkpoint hashes

Parameters

chk_pts

the set of checkpoints to assign

Definition at line 175 of file blockchain.h.

{ m_checkpoints = chk_pts; }

set_enforce_dns_checkpoints()

void Blockchain::set_enforce_dns_checkpoints

(

bool

enforce

)

configure whether or not to enforce DNS-based checkpoints

Parameters

enforce

the new enforcement setting

Definition at line 4307 of file blockchain.cpp.

{
  m_enforce_dns_checkpoints = enforce_checkpoints;
}

set_reorg_notify()

void cryptonote::Blockchain::set_reorg_notify ( const std::shared_ptr< tools::Notify > & notify )

inline

sets a reorg notify object to call for every reorg

Parameters

notify

the notify object to call at every reorg

Definition at line 792 of file blockchain.h.

{ m_reorg_notify = notify; }

set_show_time_stats()

void cryptonote::Blockchain::set_show_time_stats ( bool stats )

inline

set whether or not to show/print time statistics

Parameters

stats

the new time stats setting

Definition at line 804 of file blockchain.h.

{ m_show_time_stats = stats; }

set_user_options()

void Blockchain::set_user_options	(	uint64_t	maxthreads,
		bool	sync_on_blocks,
		uint64_t	sync_threshold,
		blockchain_db_sync_mode	sync_mode,
		bool	fast_sync,
		std::string	validator_key )

Update the validators public key by fetching data from electroneum's endpoint.

Returns

true if successfull

sets various performance options

Parameters

maxthreads	max number of threads when preparing blocks for addition
sync_on_blocks	whether to sync based on blocks or bytes
sync_threshold	number of blocks/bytes to cache before syncing to database
sync_mode	the ::blockchain_db_sync_mode to use
fast_sync	sync using built-in block hashes as trusted

Definition at line 4817 of file blockchain.cpp.

{
  if (sync_mode == db_defaultsync)
  {
    m_db_default_sync = true;
    sync_mode = db_async;
  }
  m_db_sync_mode = sync_mode;
  m_fast_sync = fast_sync;
  m_db_sync_on_blocks = sync_on_blocks;
  m_db_sync_threshold = sync_threshold;
  m_max_prepare_blocks_threads = maxthreads;
 
  if(!validator_key.empty()) {
    m_validator_key = boost::algorithm::unhex(validator_key);
  }
}

set_validator_key()

void cryptonote::Blockchain::set_validator_key ( std::string key )

inline

set validator key

Definition at line 1064 of file blockchain.h.

{ m_validator_key = boost::algorithm::unhex(key); }

set_validators_list_instance()

void cryptonote::Blockchain::set_validators_list_instance ( std::unique_ptr< electroneum::basic::Validators > & v )

inline

Definition at line 1066 of file blockchain.h.

{ m_validators = v.get(); }

sign_block()

void Blockchain::sign_block	(	block &	b,
		std::string	privateKey )

Digitally sign the block.

Parameters

b	the block to be digitally signed
privateKey	key to generate the signature

Definition at line 1811 of file blockchain.cpp.

                                                                {
  crypto::hash tx_tree_hash = get_tx_tree_hash(b);
 
  std::string signature = crypto::sign_message(std::string(reinterpret_cast<char const*>(tx_tree_hash.data), sizeof(tx_tree_hash.data)), privateKey);
  if(signature.empty() || signature.size() != 64) {
    LOG_ERROR("The daemon has failed to digitally sign a block and therefore it cannot be accepted by the network. Please check your validator-key configuration before resuming mining.");
    return;
  }
 
  b.signature = std::vector<uint8_t>(signature.begin(), signature.end());
}

Here is the call graph for this function:

Here is the caller graph for this function:

store_blockchain()

bool Blockchain::store_blockchain

(

)

stores the blockchain

If Blockchain is handling storing of the blockchain (rather than BlockchainDB), this initiates a blockchain save.

Returns

true unless saving the blockchain fails

Definition at line 630 of file blockchain.cpp.

{
  LOG_PRINT_L3("Blockchain::" << __func__);
  // lock because the rpc_thread command handler also calls this
  CRITICAL_REGION_LOCAL(m_db->m_synchronization_lock);
 
  TIME_MEASURE_START(save);
  // TODO: make sure sync(if this throws that it is not simply ignored higher
  // up the call stack
  try
  {
    m_db->sync();
  }
  catch (const std::exception& e)
  {
    MERROR(std::string("Error syncing blockchain db: ") + e.what() + "-- shutting down now to prevent issues!");
    throw;
  }
  catch (...)
  {
    MERROR("There was an issue storing the blockchain, shutting down now to prevent issues!");
    throw;
  }
 
  TIME_MEASURE_FINISH(save);
  if(m_show_time_stats)
    MINFO("Blockchain stored OK, took: " << save << " ms");
  return true;
}

Here is the caller graph for this function:

unlock()

void Blockchain::unlock

(

)

Definition at line 5036 of file blockchain.cpp.

{
  m_blockchain_lock.unlock();
}

update_blockchain_pruning()

bool Blockchain::update_blockchain_pruning

(

)

Definition at line 4082 of file blockchain.cpp.

{
  m_tx_pool.lock();
  epee::misc_utils::auto_scope_leave_caller unlocker = epee::misc_utils::create_scope_leave_handler([&](){m_tx_pool.unlock();});
  CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
  return m_db->update_pruning();
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_checkpoints()

bool Blockchain::update_checkpoints	(	const std::string &	file_path,
		bool	check_dns )

loads new checkpoints from a file and optionally from DNS

Parameters

file_path	the path of the file to look for and load checkpoints from
check_dns	whether or not to check for new DNS-based checkpoints

Returns

false if any enforced checkpoint type fails to load, otherwise true

Definition at line 4272 of file blockchain.cpp.

{
  if (!m_checkpoints.load_checkpoints_from_json(file_path))
  {
      return false;
  }
 
  // if we're checking both dns and json, load checkpoints from dns.
  // if we're not hard-enforcing dns checkpoints, handle accordingly
  if (m_enforce_dns_checkpoints && check_dns && !m_offline)
  {
    if (!m_checkpoints.load_checkpoints_from_dns())
    {
      return false;
    }
  }
  else if (check_dns && !m_offline)
  {
    checkpoints dns_points;
    dns_points.load_checkpoints_from_dns();
    if (m_checkpoints.check_for_conflicts(dns_points))
    {
      check_against_checkpoints(dns_points, false);
    }
    else
    {
      MERROR("One or more checkpoints fetched from DNS conflicted with existing checkpoints!");
    }
  }
 
  check_against_checkpoints(m_checkpoints, true);
 
  return true;
}

Here is the call graph for this function:

update_txpool_tx()

void Blockchain::update_txpool_tx	(	const crypto::hash &	txid,
		const txpool_tx_meta_t &	meta )

Definition at line 4773 of file blockchain.cpp.

{
  m_db->update_txpool_tx(txid, meta);
}

utxo_nonexistence_from_output()

bool Blockchain::utxo_nonexistence_from_output

(

const txin_to_key_public &

public_output

)

const

check if a single utxo in a transaction has already been spent using the hash and out index (v3 tx onwards)

Parameters

public_output

the output to check

Returns

true if any utxo is nonexistent, else false

Definition at line 2993 of file blockchain.cpp.

{
    LOG_PRINT_L3("Blockchain::" << __func__);
 
    if(!m_db->check_chainstate_utxo(public_output.tx_hash, public_output.relative_offset))
        return true;
 
    return false;
}

utxo_nonexistent()

bool Blockchain::utxo_nonexistent

(

const transaction &

tx

)

const

check if any utxo in a transaction has already been spent using the tx (v3 tx onwards)

Parameters

tx	the transaction to check

Returns

true if any utxo is nonexistent, else false

Definition at line 2975 of file blockchain.cpp.

{
    LOG_PRINT_L3("Blockchain::" << __func__);
 
    for (const txin_v& in: tx.vin)
    {
        if(in.type() == typeid(txin_to_key_public))
        {
          const auto &in_to_key = boost::get<txin_to_key_public>(in);
          if(!m_db->check_chainstate_utxo(in_to_key.tx_hash, in_to_key.relative_offset))
              return true;
        }
    }
    return false;
}

verify_block_signature()

bool Blockchain::verify_block_signature

(

const block &

b

)

Verify block's digital signature.

Parameters

b	block to be verified

Definition at line 1823 of file blockchain.cpp.

                                                      {
  crypto::hash tx_tree_hash = get_tx_tree_hash(b);
  const std::vector<std::string> public_keys = m_validators->getApplicablePublicKeys(m_db->height(), true);
 
  for(auto &key : public_keys) {
    if(crypto::verify_signature(std::string(reinterpret_cast<char const *>(tx_tree_hash.data), sizeof(tx_tree_hash.data)),
                             key, std::string(b.signature.begin(), b.signature.end()))){
        b.signatory = std::vector<uint8_t>(key.begin(), key.end());
        return true;
    }
  }
  return false;
}

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