handles core cryptonote functionality More...

#include <cryptonote_core.h>

Inheritance diagram for cryptonote::core:

Collaboration diagram for cryptonote::core:

Public Member Functions
	core (i_cryptonote_protocol *pprotocol)
	constructor More...

bool	handle_get_objects (NOTIFY_REQUEST_GET_OBJECTS::request &arg, NOTIFY_RESPONSE_GET_OBJECTS::request &rsp, cryptonote_connection_context &context)
	retrieves a set of blocks and their transactions, and possibly other transactions More...

bool	on_idle ()
	calls various idle routines More...

bool	handle_incoming_tx (const blobdata &tx_blob, tx_verification_context &tvc, bool keeped_by_block, bool relayed, bool do_not_relay)
	handles an incoming transaction More...

bool	handle_incoming_txs (const std::vector< blobdata > &tx_blobs, std::vector< tx_verification_context > &tvc, bool keeped_by_block, bool relayed, bool do_not_relay)
	handles a list of incoming transactions More...

bool	handle_incoming_block (const blobdata &block_blob, const block *b, block_verification_context &bvc, bool update_miner_blocktemplate=true)
	handles an incoming block More...

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

bool	cleanup_handle_incoming_blocks (bool force_sync=false)
	incoming blocks post-processing, cleanup, and disk sync More...

bool	check_incoming_block_size (const blobdata &block_blob) const
	check the size of a block against the current maximum More...

i_cryptonote_protocol *	get_protocol ()
	get the cryptonote protocol instance More...

virtual bool	handle_block_found (block &b, block_verification_context &bvc)
	stores and relays a block found by a miner More...

virtual bool	get_block_template (block &b, const account_public_address &adr, difficulty_type &diffic, uint64_t &height, uint64_t &expected_reward, const blobdata &ex_nonce)
	creates a new block to mine against More...

virtual bool	get_block_template (block &b, const crypto::hash *prev_block, const account_public_address &adr, difficulty_type &diffic, uint64_t &height, uint64_t &expected_reward, const blobdata &ex_nonce)

virtual void	on_transaction_relayed (const cryptonote::blobdata &tx)
	called when a transaction is relayed More...

miner &	get_miner ()
	gets the miner instance More...

const miner &	get_miner () const
	gets the miner instance (const) More...

bool	init (const boost::program_options::variables_map &vm, const test_options *test_options=NULL, const GetCheckpointsCallback &get_checkpoints=nullptr)
	initializes the core as needed More...

bool	set_genesis_block (const block &b)
	clears the blockchain and starts a new one More...

bool	deinit ()
	performs safe shutdown steps for core and core components More...

void	test_drop_download ()
	sets to drop blocks downloaded (for testing) More...

void	test_drop_download_height (uint64_t height)
	sets to drop blocks downloaded below a certain height More...

bool	get_test_drop_download () const
	gets whether or not to drop blocks (for testing) More...

bool	get_test_drop_download_height () const
	gets whether or not to drop blocks More...

uint64_t	get_current_blockchain_height () const
	get the current height of the blockchain More...

void	get_blockchain_top (uint64_t &height, crypto::hash &top_id) const
	get the hash and height of the most recent block More...

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

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

bool	get_blocks (uint64_t start_offset, size_t count, std::vector< block > &blocks) const
	get blocks from blocks based on start height and count More...

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

crypto::hash	get_block_id_by_height (uint64_t height) const
	gets a block's hash given a height More...

bool	get_transactions (const std::vector< crypto::hash > &txs_ids, std::vector< cryptonote::blobdata > &txs, std::vector< crypto::hash > &missed_txs) const

bool	get_split_transactions_blobs (const std::vector< crypto::hash > &txs_ids, std::vector< std::tuple< crypto::hash, cryptonote::blobdata, crypto::hash, cryptonote::blobdata >> &txs, std::vector< crypto::hash > &missed_txs) const

bool	get_transactions (const std::vector< crypto::hash > &txs_ids, std::vector< transaction > &txs, std::vector< crypto::hash > &missed_txs) const

bool	get_block_by_hash (const crypto::hash &h, block &blk, bool *orphan=NULL) const
	gets the block with a given hash More...

bool	get_alternative_blocks (std::vector< block > &blocks) const
	compiles a list of all blocks stored as alternative chains More...

size_t	get_alternative_blocks_count () const
	returns the number of alternative blocks stored More...

void	set_cryptonote_protocol (i_cryptonote_protocol *pprotocol)
	set the pointer to the cryptonote protocol object to use More...

void	set_checkpoints (checkpoints &&chk_pts)
	assign a set of blockchain checkpoint hashes More...

void	set_checkpoints_file_path (const std::string &path)
	set the file path to read from when loading checkpoints More...

void	set_enforce_dns_checkpoints (bool enforce_dns)
	set whether or not we enforce DNS checkpoints More...

void	disable_dns_checkpoints (bool disable=true)
	set whether or not to enable or disable DNS checkpoints More...

bool	pool_has_tx (const crypto::hash &txid) const
	checks if the pool has a transaction with the given hash More...

bool	get_pool_transactions (std::vector< transaction > &txs, bool include_unrelayed_txes=true) const
	get a list of all transactions in the pool More...

bool	get_txpool_backlog (std::vector< tx_backlog_entry > &backlog) const

bool	get_pool_transaction_hashes (std::vector< crypto::hash > &txs, bool include_unrelayed_txes=true) const
	get a list of all transactions in the pool More...

bool	get_pool_transaction_stats (struct txpool_stats &stats, bool include_unrelayed_txes=true) const
	get a list of all transactions in the pool More...

bool	get_pool_transaction (const crypto::hash &id, cryptonote::blobdata &tx) const
	get a specific transaction from the pool More...

bool	get_pool_transactions_and_spent_keys_info (std::vector< tx_info > &tx_infos, std::vector< spent_key_image_info > &key_image_infos, bool include_unrelayed_txes=true) const

bool	get_pool_for_rpc (std::vector< cryptonote::rpc::tx_in_pool > &tx_infos, cryptonote::rpc::key_images_with_tx_hashes &key_image_infos) const
	get information about all transactions and key images in the pool More...

size_t	get_pool_transactions_count () const
	get the total number of transactions in the pool More...

size_t	get_blockchain_total_transactions () const
	gets the total number of transactions on the main chain More...

bool	have_block (const crypto::hash &id) const
	checks if a block is known about with a given hash More...

bool	get_short_chain_history (std::list< crypto::hash > &ids) const
	gets the hashes for a subset of the blockchain More...

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

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

bool	get_stat_info (core_stat_info &st_inf) const
	gets some stats about the daemon More...

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

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

crypto::hash	get_tail_id () const
	get the hash of the most recent block on the blockchain More...

void	set_block_cumulative_difficulty (uint64_t height, difficulty_type diff)

difficulty_type	get_block_cumulative_difficulty (uint64_t height) const

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

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

void	pause_mine ()

void	resume_mine ()

Blockchain &	get_blockchain_storage ()
	gets the Blockchain instance More...

const Blockchain &	get_blockchain_storage () const
	gets the Blockchain instance (const) More...

std::string	print_pool (bool short_format) const
	get a string containing human-readable pool information More...

void	on_synchronized ()

void	safesyncmode (const bool onoff)
	Put DB in safe sync mode. More...

void	set_target_blockchain_height (uint64_t target_blockchain_height)
	sets the target blockchain height More...

uint64_t	get_target_blockchain_height () const
	gets the target blockchain height More...

uint8_t	get_ideal_hard_fork_version () const
	returns the newest hardfork version known to the blockchain More...

uint8_t	get_ideal_hard_fork_version (uint64_t height) const
	return the ideal hard fork version for a given block height More...

uint8_t	get_hard_fork_version (uint64_t height) const
	return the hard fork version for a given block height More...

uint64_t	get_earliest_ideal_height_for_version (uint8_t version) const
	return the earliest block a given version may activate More...

std::time_t	get_start_time () const
	gets start_time More...

bool	update_checkpoints ()
	tells the Blockchain to update its checkpoints More...

std::string	get_validators_list ()
	Get a serialized representation of the list of validators. More...

electroneum::basic::list_update_outcome	set_validators_list (std::string v_list, bool isEmergencyUpdate)
	set the list of validators according to the serialized string passed in as parameter More...

bool	isValidatorsListValid ()
	get Validators List state More...

void	graceful_exit ()
	tells the daemon to wind down operations and stop running More...

void	stop ()
	stops the daemon running More...

bool	is_key_image_spent (const crypto::key_image &key_im) const
	check if a key image is already spent on the blockchain More...

bool	are_key_images_spent (const std::vector< crypto::key_image > &key_im, std::vector< bool > &spent) const
	check if multiple key images are spent More...

bool	are_key_images_spent_in_pool (const std::vector< crypto::key_image > &key_im, std::vector< bool > &spent) const
	check if multiple key images are spent in the transaction pool More...

size_t	get_block_sync_size (uint64_t height) const
	get the number of blocks to sync in one go More...

std::pair< uint64_t, uint64_t >	get_coinbase_tx_sum (const uint64_t start_offset, const size_t count)
	get the sum of coinbase tx amounts between blocks More...

network_type	get_nettype () const
	get the network type we're on More...

bool	is_update_available () const
	check whether an update is known to be available or not More...

bool	fluffy_blocks_enabled () const
	get whether fluffy blocks are enabled More...

bool	pad_transactions () const
	get whether transaction relay should be padded More...

uint64_t	get_free_space () const
	get free disk space on the blockchain partition More...

bool	offline () const
	get whether the core is running offline More...

uint32_t	get_blockchain_pruning_seed () const
	get the blockchain pruning seed More...

bool	prune_blockchain (uint32_t pruning_seed=0)
	prune the blockchain More...

bool	update_blockchain_pruning ()
	incrementally prunes blockchain More...

bool	check_blockchain_pruning ()
	checks the blockchain pruning if enabled More...

bool	set_validator_key (std::string key)
	set validator key More...

std::vector< std::string >	generate_ed25519_keypair ()

std::string	sign_message (std::string sk, std::string msg)

uint64_t	get_balance (const address_parse_info &addr)

std::vector< address_outputs >	get_address_batch_history (const address_parse_info &addr, const uint64_t &start_tx_id=0, const uint64_t &batch_size=100, bool desc=false)

Static Public Member Functions
static void	init_options (boost::program_options::options_description &desc)
	adds command line options to the given options set More...

Additional Inherited Members
Protected Member Functions inherited from cryptonote::i_miner_handler
	~i_miner_handler ()

Detailed Description

handles core cryptonote functionality

This class coordinates cryptonote functionality including, but not limited to, communication among the Blockchain, the transaction pool, any miners, and the network.

Definition at line 85 of file cryptonote_core.h.

Constructor & Destructor Documentation

◆ core()

cryptonote::core::core ( i_cryptonote_protocol * pprotocol )

constructor

sets member variables into a usable state

Parameters

pprotocol pre-constructed protocol object to store and use

Definition at line 248 of file cryptonote_core.cpp.

                                             :
               m_mempool(m_blockchain_storage),
               m_blockchain_storage(m_mempool),
               m_miner(this),
               m_miner_address(boost::value_initialized<account_public_address>()),
               m_starter_message_showed(false),
               m_target_blockchain_height(0),
               m_checkpoints_path(""),
               m_last_dns_checkpoints_update(0),
               m_last_json_checkpoints_update(0),
               m_disable_dns_checkpoints(false),
               m_update_download(0),
               m_nettype(UNDEFINED),
               m_update_available(false),
               m_pad_transactions(false)
   {
     m_checkpoints_updating.clear();
     set_cryptonote_protocol(pprotocol);
   }

Here is the call graph for this function:

Member Function Documentation

◆ are_key_images_spent()

bool cryptonote::core::are_key_images_spent	(	const std::vector< crypto::key_image > &	key_im,
		std::vector< bool > &	spent
	)		const

check if multiple key images are spent

plural version of is_key_image_spent()

Parameters

key_im	list of key images to check
spent	return-by-reference result for each image checked

Returns: true

Definition at line 1135 of file cryptonote_core.cpp.

   {
     spent.clear();
     for(auto& ki: key_im)
     {
       spent.push_back(m_blockchain_storage.have_tx_keyimg_as_spent(ki));
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ are_key_images_spent_in_pool()

bool cryptonote::core::are_key_images_spent_in_pool	(	const std::vector< crypto::key_image > &	key_im,
		std::vector< bool > &	spent
	)		const

check if multiple key images are spent in the transaction pool

Parameters

key_im	list of key images to check
spent	return-by-reference result for each image checked

Returns: true

Definition at line 1155 of file cryptonote_core.cpp.

   {
     spent.clear();
     return m_mempool.check_for_key_images(key_im, spent);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_blockchain_pruning()

bool cryptonote::core::check_blockchain_pruning ( )

checks the blockchain pruning if enabled

Returns: true on success, false otherwise

Definition at line 1952 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.check_blockchain_pruning();
   }

Here is the call graph for this function:

◆ check_incoming_block_size()

bool cryptonote::core::check_incoming_block_size ( const blobdata & block_blob ) const

check the size of a block against the current maximum

Parameters

block_blob the block to check

Returns: whether or not the block is too big

Definition at line 1516 of file cryptonote_core.cpp.

   {
     // note: we assume block weight is always >= block blob size, so we check incoming
     // blob size against the block weight limit, which acts as a sanity check without
     // having to parse/weigh first; in fact, since the block blob is the block header
     // plus the tx hashes, the weight will typically be much larger than the blob size
     if(block_blob.size() > m_blockchain_storage.get_current_cumulative_block_weight_limit() + BLOCK_SIZE_SANITY_LEEWAY)
     {
       LOG_PRINT_L1("WRONG BLOCK BLOB, sanity check failed on size " << block_blob.size() << ", rejected");
       return false;
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cleanup_handle_incoming_blocks()

bool cryptonote::core::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

Note: see Blockchain::cleanup_handle_incoming_blocks

Definition at line 1456 of file cryptonote_core.cpp.

   {
     bool success = false;
     try {
       success = m_blockchain_storage.cleanup_handle_incoming_blocks(force_sync);
     }
     catch (...) {}
     m_incoming_tx_lock.unlock();
     return success;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deinit()

bool cryptonote::core::deinit ( )

performs safe shutdown steps for core and core components

Uninitializes the miner instance, transaction pool, and Blockchain

Returns: true

Definition at line 783 of file cryptonote_core.cpp.

   {
     m_miner.stop();
     m_mempool.deinit();
     m_blockchain_storage.deinit();
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disable_dns_checkpoints()

void cryptonote::core::disable_dns_checkpoints ( bool disable = true )

inline

set whether or not to enable or disable DNS checkpoints

Parameters

disble whether to disable DNS checkpoints

Definition at line 436 of file cryptonote_core.h.

436 { m_disable_dns_checkpoints = disable; }

◆ find_blockchain_supplement() [1/2]

bool cryptonote::core::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

Note: see Blockchain::find_blockchain_supplement(const std::list<crypto::hash>&, NOTIFY_RESPONSE_CHAIN_ENTRY::request&) const

Definition at line 1317 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.find_blockchain_supplement(qblock_ids, resp);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_blockchain_supplement() [2/2]

bool cryptonote::core::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

Note: see Blockchain::find_blockchain_supplement(const uint64_t, const std::list<crypto::hash>&, std::vector<std::pair<cryptonote::blobdata, std::vector<transaction> > >&, uint64_t&, uint64_t&, size_t) const

Definition at line 1322 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.find_blockchain_supplement(req_start_block, qblock_ids, blocks, total_height, start_height, pruned, get_miner_tx_hash, max_count);
   }

Here is the call graph for this function:

◆ fluffy_blocks_enabled()

bool cryptonote::core::fluffy_blocks_enabled ( ) const

inline

get whether fluffy blocks are enabled

Returns: whether fluffy blocks are enabled

Definition at line 803 of file cryptonote_core.h.

803 { return m_fluffy_blocks_enabled; }

◆ generate_ed25519_keypair()

std::vector< std::string > cryptonote::core::generate_ed25519_keypair ( )

Definition at line 2002 of file cryptonote_core.cpp.

                                                       {
     return crypto::create_ed25519_keypair();
   }

Here is the call graph for this function:

◆ get_address_batch_history()

std::vector< address_outputs > cryptonote::core::get_address_batch_history	(	const address_parse_info &	addr,
		const uint64_t &	start_tx_id = `0`,
		const uint64_t &	batch_size = `100`,
		bool	desc = `false`
	)

Definition at line 2018 of file cryptonote_core.cpp.

   {
     crypto::public_key combined_key = crypto::addKeys(addr.address.m_view_public_key, addr.address.m_spend_public_key);
     return m_blockchain_storage.get_db().get_addr_output_batch(combined_key, start_tx_id, batch_size, desc);
   }

Here is the call graph for this function:

◆ get_alternative_blocks()

bool cryptonote::core::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

Note: see Blockchain::get_alternative_blocks(std::vector<block>&) const

Definition at line 487 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_alternative_blocks(blocks);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_alternative_blocks_count()

size_t cryptonote::core::get_alternative_blocks_count ( ) const

returns the number of alternative blocks stored

Returns: the number of alternative blocks stored

Note: see Blockchain::get_alternative_blocks_count() const

Definition at line 492 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_alternative_blocks_count();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_balance()

uint64_t cryptonote::core::get_balance ( const address_parse_info & addr )

Definition at line 2012 of file cryptonote_core.cpp.

   {
     crypto::public_key combined_key = crypto::addKeys(addr.address.m_view_public_key, addr.address.m_spend_public_key);
     return m_blockchain_storage.get_db().get_balance(combined_key);
   }

Here is the call graph for this function:

◆ get_block_by_hash()

bool cryptonote::core::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

Note: see Blockchain::get_block_by_hash

Definition at line 1618 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_block_by_hash(h, blk, orphan);
   }

Here is the call graph for this function:

◆ get_block_cumulative_difficulty()

difficulty_type cryptonote::core::get_block_cumulative_difficulty ( uint64_t height ) const

Note: see Blockchain::get_block_cumulative_difficulty

Definition at line 1540 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_db().get_block_cumulative_difficulty(height);
   }

Here is the call graph for this function:

◆ get_block_id_by_height()

crypto::hash cryptonote::core::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

Note: see Blockchain::get_block_id_by_height

Definition at line 1613 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_block_id_by_height(height);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_sync_size()

size_t cryptonote::core::get_block_sync_size ( uint64_t height ) const

get the number of blocks to sync in one go

Returns: the number of blocks to sync in one go

Definition at line 1145 of file cryptonote_core.cpp.

   {
     static const uint64_t quick_height = m_nettype == TESTNET ? 801219 : m_nettype == MAINNET ? 1220516 : 0;
     if (block_sync_size > 0)
       return block_sync_size;
     if (height >= quick_height)
       return BLOCKS_SYNCHRONIZING_DEFAULT_COUNT;
     return BLOCKS_SYNCHRONIZING_DEFAULT_COUNT_PRE_V4;
   }

◆ get_block_template() [1/2]

bool cryptonote::core::get_block_template	(	block &	b,
		const account_public_address &	adr,
		difficulty_type &	diffic,
		uint64_t &	height,
		uint64_t &	expected_reward,
		const blobdata &	ex_nonce
	)

virtual

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

Note: see Blockchain::create_block_template

Implements cryptonote::i_miner_handler.

Definition at line 1307 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.create_block_template(b, adr, diffic, height, expected_reward, ex_nonce);
   }

Here is the call graph for this function:

◆ get_block_template() [2/2]

bool cryptonote::core::get_block_template	(	block &	b,
		const crypto::hash *	prev_block,
		const account_public_address &	adr,
		difficulty_type &	diffic,
		uint64_t &	height,
		uint64_t &	expected_reward,
		const blobdata &	ex_nonce
	)

virtual

Definition at line 1312 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.create_block_template(b, prev_block, adr, diffic, height, expected_reward, ex_nonce);
   }

Here is the call graph for this function:

◆ get_blockchain_pruning_seed()

uint32_t cryptonote::core::get_blockchain_pruning_seed ( ) const

get the blockchain pruning seed

Returns: the blockchain pruning seed

Definition at line 1974 of file cryptonote_core.cpp.

   {
     return get_blockchain_storage().get_blockchain_pruning_seed();
   }

Here is the call graph for this function:

◆ get_blockchain_storage() [1/2]

Blockchain& cryptonote::core::get_blockchain_storage ( )

inline

gets the Blockchain instance

Returns: a reference to the Blockchain instance

Definition at line 611 of file cryptonote_core.h.

611 {return m_blockchain_storage;}

Here is the caller graph for this function:

◆ get_blockchain_storage() [2/2]

const Blockchain& cryptonote::core::get_blockchain_storage ( ) const

inline

gets the Blockchain instance (const)

Returns: a const reference to the Blockchain instance

Definition at line 618 of file cryptonote_core.h.

618 {return m_blockchain_storage;}

◆ get_blockchain_top()

void cryptonote::core::get_blockchain_top	(	uint64_t &	height,
		crypto::hash &	top_id
	)		const

get the hash and height of the most recent block

Parameters

height	return-by-reference height of the block
top_id	return-by-reference hash of the block

Definition at line 441 of file cryptonote_core.cpp.

   {
     top_id = m_blockchain_storage.get_tail_id(height);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_blockchain_total_transactions()

size_t cryptonote::core::get_blockchain_total_transactions ( ) const

gets the total number of transactions on the main chain

Returns: the number of transactions on the main chain

Note: see Blockchain::get_total_transactions

Definition at line 1250 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_total_transactions();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_blocks() [1/4]

template<class t_ids_container , class t_blocks_container , class t_missed_container >

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

inline

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

Note: see Blockchain::get_blocks(const t_ids_container&, t_blocks_container&, t_missed_container&) const

Definition at line 349 of file cryptonote_core.h.

      {
        return m_blockchain_storage.get_blocks(block_ids, blocks, missed_bs);
      }

◆ get_blocks() [2/4]

bool cryptonote::core::get_blocks	(	uint64_t	start_offset,
		size_t	count,
		std::vector< 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

Note: see Blockchain::get_blocks(uint64_t, size_t, std::vector<std::pair<cryptonote::blobdata,block>>&) const

Definition at line 456 of file cryptonote_core.cpp.

   {
     std::vector<std::pair<cryptonote::blobdata, cryptonote::block>> bs;
     if (!m_blockchain_storage.get_blocks(start_offset, count, bs))
       return false;
     for (const auto &b: bs)
       blocks.push_back(b.second);
     return true;
   }

Here is the call graph for this function:

◆ get_blocks() [3/4]

bool cryptonote::core::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

Note: see Blockchain::get_blocks(uint64_t, size_t, std::vector<std::pair<cryptonote::blobdata,block>>&) const

Definition at line 451 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_blocks(start_offset, count, blocks);
   }

Here is the call graph for this function:

◆ get_blocks() [4/4]

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

Note: see Blockchain::get_blocks(uint64_t, size_t, std::vector<std::pair<cryptonote::blobdata,block>>&, std::vector<transaction>&) const

Definition at line 446 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_blocks(start_offset, count, blocks, txs);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_coinbase_tx_sum()

std::pair< uint64_t, uint64_t > cryptonote::core::get_coinbase_tx_sum	(	const uint64_t	start_offset,
		const size_t	count
	)

get the sum of coinbase tx amounts between blocks

Returns: the number of blocks to sync in one go

Definition at line 1161 of file cryptonote_core.cpp.

   {
     uint64_t emission_amount = 0;
     uint64_t total_fee_amount = 0;
     if (count)
     {
       const uint64_t end = start_offset + count - 1;
       m_blockchain_storage.for_blocks_range(start_offset, end,
         [this, &emission_amount, &total_fee_amount](uint64_t, const crypto::hash& hash, const block& b){
       std::vector<transaction> txs;
       std::vector<crypto::hash> missed_txs;
       uint64_t coinbase_amount = get_outs_etn_amount(b.miner_tx);
       this->get_transactions(b.tx_hashes, txs, missed_txs);      
       uint64_t tx_fee_amount = 0;
       for(const auto& tx: txs)
       {
         tx_fee_amount += get_tx_fee(tx);
       }
       
       emission_amount += coinbase_amount - tx_fee_amount;
       total_fee_amount += tx_fee_amount;
       return true;
       });
     }
  
     return std::pair<uint64_t, uint64_t>(emission_amount, total_fee_amount);
   }

Here is the call graph for this function:

◆ get_current_blockchain_height()

uint64_t cryptonote::core::get_current_blockchain_height ( ) const

get the current height of the blockchain

Returns: the height

Note: see Blockchain::get_current_blockchain_height()

Definition at line 436 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_current_blockchain_height();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_earliest_ideal_height_for_version()

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

return the earliest block a given version may activate

Returns: what it says above

Definition at line 1711 of file cryptonote_core.cpp.

   {
     return get_blockchain_storage().get_earliest_ideal_height_for_version(version);
   }

Here is the call graph for this function:

◆ get_free_space()

uint64_t cryptonote::core::get_free_space ( ) const

get free disk space on the blockchain partition

Returns: free space in bytes

Definition at line 1967 of file cryptonote_core.cpp.

   {
     boost::filesystem::path path(m_config_folder);
     boost::filesystem::space_info si = boost::filesystem::space(path);
     return si.available;
   }

Here is the caller graph for this function:

◆ get_hard_fork_version()

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

return the hard fork version for a given block height

Returns: what it says above

Definition at line 1706 of file cryptonote_core.cpp.

   {
     return get_blockchain_storage().get_hard_fork_version(height);
   }

Here is the call graph for this function:

◆ get_ideal_hard_fork_version() [1/2]

uint8_t cryptonote::core::get_ideal_hard_fork_version ( ) const

returns the newest hardfork version known to the blockchain

Returns: the version

Definition at line 1696 of file cryptonote_core.cpp.

   {
     return get_blockchain_storage().get_ideal_hard_fork_version();
   }

Here is the call graph for this function:

◆ get_ideal_hard_fork_version() [2/2]

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

return the ideal hard fork version for a given block height

Returns: what it says above

Definition at line 1701 of file cryptonote_core.cpp.

   {
     return get_blockchain_storage().get_ideal_hard_fork_version(height);
   }

Here is the call graph for this function:

◆ get_miner() [1/2]

miner& cryptonote::core::get_miner ( )

inline

gets the miner instance

Returns: a reference to the miner instance

Definition at line 229 of file cryptonote_core.h.

229 {return m_miner;}

Here is the caller graph for this function:

◆ get_miner() [2/2]

const miner& cryptonote::core::get_miner ( ) const

inline

gets the miner instance (const)

Returns: a const reference to the miner instance

Definition at line 236 of file cryptonote_core.h.

236 {return m_miner;}

◆ get_nettype()

network_type cryptonote::core::get_nettype ( ) const

inline

get the network type we're on

Returns: which network are we on?

Definition at line 786 of file cryptonote_core.h.

786 { return m_nettype; };

Here is the caller graph for this function:

◆ get_output_distribution()

bool cryptonote::core::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

get per block distribution of outputs of a given amount

Definition at line 1332 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_output_distribution(amount, from_height, to_height, start_height, distribution, base);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_outs()

bool cryptonote::core::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

Note: see Blockchain::get_outs

Definition at line 1327 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_outs(req, res);
   }

Here is the call graph for this function:

◆ get_pool_for_rpc()

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

get information about all transactions and key images in the pool

see documentation on tx_in_pool and key_images_with_tx_hashes for more details

Parameters

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

Returns: true

Note: see tx_memory_pool::get_pool_for_rpc

Definition at line 1598 of file cryptonote_core.cpp.

   {
     return m_mempool.get_pool_for_rpc(tx_infos, key_image_infos);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_pool_transaction()

bool cryptonote::core::get_pool_transaction	(	const crypto::hash &	id,
		cryptonote::blobdata &	tx
	)		const

get a specific transaction from the pool

Parameters

h	the hash of the transaction to get
tx	return-by-reference the transaction blob requested

Returns: true if the transaction is found, otherwise false

Note: see tx_memory_pool::get_transaction

Definition at line 1583 of file cryptonote_core.cpp.

   {
     return m_mempool.get_transaction(id, tx);
   }  

Here is the call graph for this function:

◆ get_pool_transaction_hashes()

bool cryptonote::core::get_pool_transaction_hashes	(	std::vector< crypto::hash > &	txs,
		bool	include_unrelayed_txes = `true`
	)		const

get a list of all transactions in the pool

Parameters

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

Note: see tx_memory_pool::get_transactions

Definition at line 1571 of file cryptonote_core.cpp.

   {
     m_mempool.get_transaction_hashes(txs, include_sensitive_data);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_pool_transaction_stats()

bool cryptonote::core::get_pool_transaction_stats	(	struct txpool_stats &	stats,
		bool	include_unrelayed_txes = `true`
	)		const

get a list of all transactions in the pool

Parameters

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

Note: see tx_memory_pool::get_transactions

Definition at line 1577 of file cryptonote_core.cpp.

   {
     m_mempool.get_transaction_stats(stats, include_sensitive_data);
     return true;
   }

Here is the call graph for this function:

◆ get_pool_transactions()

bool cryptonote::core::get_pool_transactions	(	std::vector< transaction > &	txs,
		bool	include_unrelayed_txes = `true`
	)		const

get a list of all transactions in the pool

Parameters

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

Note: see tx_memory_pool::get_transactions

Definition at line 1565 of file cryptonote_core.cpp.

   {
     m_mempool.get_transactions(txs, include_sensitive_data);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_pool_transactions_and_spent_keys_info()

bool cryptonote::core::get_pool_transactions_and_spent_keys_info	(	std::vector< tx_info > &	tx_infos,
		std::vector< spent_key_image_info > &	key_image_infos,
		bool	include_unrelayed_txes = `true`
	)		const

Parameters

include_unrelayed_txes include unrelayed txes in result

Note: see tx_memory_pool::get_pool_transactions_and_spent_keys_info

Definition at line 1593 of file cryptonote_core.cpp.

   {
     return m_mempool.get_transactions_and_spent_keys_info(tx_infos, key_image_infos, include_sensitive_data);
   }

Here is the call graph for this function:

◆ get_pool_transactions_count()

size_t cryptonote::core::get_pool_transactions_count ( ) const

get the total number of transactions in the pool

Returns: the number of transactions in the pool

Note: see tx_memory_pool::get_transactions_count

Definition at line 1545 of file cryptonote_core.cpp.

   {
     return m_mempool.get_transactions_count();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_protocol()

i_cryptonote_protocol* cryptonote::core::get_protocol ( )

inline

get the cryptonote protocol instance

Returns: the instance

Definition at line 192 of file cryptonote_core.h.

192 {return m_pprotocol;}

◆ get_short_chain_history()

bool cryptonote::core::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

Note: see Blockchain::get_short_chain_history

Definition at line 1603 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_short_chain_history(ids);
   }

Here is the call graph for this function:

◆ get_split_transactions_blobs()

bool cryptonote::core::get_split_transactions_blobs	(	const std::vector< crypto::hash > &	txs_ids,
		std::vector< std::tuple< crypto::hash, cryptonote::blobdata, crypto::hash, cryptonote::blobdata >> &	txs,
		std::vector< crypto::hash > &	missed_txs
	)		const

Note: see Blockchain::get_transactions

Definition at line 471 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_split_transactions_blobs(txs_ids, txs, missed_txs);
   }

Here is the call graph for this function:

◆ get_start_time()

std::time_t cryptonote::core::get_start_time ( ) const

gets start_time

Definition at line 1984 of file cryptonote_core.cpp.

   {
     return start_time;
   }

Here is the caller graph for this function:

◆ get_stat_info()

bool cryptonote::core::get_stat_info ( core_stat_info & st_inf ) const

gets some stats about the daemon

Parameters

st_inf return-by-reference container for the stats requested

Returns: true

Definition at line 1048 of file cryptonote_core.cpp.

   {
     st_inf.mining_speed = m_miner.get_speed();
     st_inf.alternative_blocks = m_blockchain_storage.get_alternative_blocks_count();
     st_inf.blockchain_height = m_blockchain_storage.get_current_blockchain_height();
     st_inf.tx_pool_size = m_mempool.get_transactions_count();
     st_inf.top_block_id_str = epee::string_tools::pod_to_hex(m_blockchain_storage.get_tail_id());
     return true;
   }

Here is the call graph for this function:

◆ get_tail_id()

crypto::hash cryptonote::core::get_tail_id ( ) const

get the hash of the most recent block on the blockchain

Returns: the hash

Note: see Blockchain::get_tail_id

Definition at line 1530 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_tail_id();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_target_blockchain_height()

uint64_t cryptonote::core::get_target_blockchain_height ( ) const

gets the target blockchain height

Parameters

target_blockchain_height the target height

Definition at line 1962 of file cryptonote_core.cpp.

   {
     return m_target_blockchain_height;
   }

Here is the caller graph for this function:

◆ get_test_drop_download()

bool cryptonote::core::get_test_drop_download ( ) const

gets whether or not to drop blocks (for testing)

Returns: whether or not to drop blocks

Definition at line 801 of file cryptonote_core.cpp.

   {
     return m_test_drop_download;
   }

◆ get_test_drop_download_height()

bool cryptonote::core::get_test_drop_download_height ( ) const

gets whether or not to drop blocks

If the current blockchain height <= our block drop threshold and test drop blocks is set, return true

Returns: see above

Definition at line 806 of file cryptonote_core.cpp.

   {
     if (m_test_drop_download_height == 0)
       return true;
  
     if (get_blockchain_storage().get_current_blockchain_height() <= m_test_drop_download_height)
       return true;
  
     return false;
   }

Here is the call graph for this function:

◆ get_transactions() [1/2]

bool cryptonote::core::get_transactions	(	const std::vector< crypto::hash > &	txs_ids,
		std::vector< cryptonote::blobdata > &	txs,
		std::vector< crypto::hash > &	missed_txs
	)		const

Note: see Blockchain::get_transactions

Definition at line 466 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_transactions_blobs(txs_ids, txs, missed_txs);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_transactions() [2/2]

bool cryptonote::core::get_transactions	(	const std::vector< crypto::hash > &	txs_ids,
		std::vector< transaction > &	txs,
		std::vector< crypto::hash > &	missed_txs
	)		const

Note: see Blockchain::get_transactions

Definition at line 482 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_transactions(txs_ids, txs, missed_txs);
   }

Here is the call graph for this function:

◆ get_tx_outputs_gindexs() [1/2]

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

Definition at line 1342 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_tx_outputs_gindexs(tx_id, n_txes, indexs);
   }

Here is the call graph for this function:

◆ get_tx_outputs_gindexs() [2/2]

bool cryptonote::core::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

Note: see Blockchain::get_tx_outputs_gindexs

Definition at line 1337 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_tx_outputs_gindexs(tx_id, indexs);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_txpool_backlog()

bool cryptonote::core::get_txpool_backlog ( std::vector< tx_backlog_entry > & backlog ) const

Note: see tx_memory_pool::get_txpool_backlog

Definition at line 476 of file cryptonote_core.cpp.

   {
     m_mempool.get_transaction_backlog(backlog);
     return true;
   }

Here is the call graph for this function:

◆ get_validators_list()

std::string cryptonote::core::get_validators_list ( )

Get a serialized representation of the list of validators.

Returns: serialized string

Definition at line 319 of file cryptonote_core.cpp.

                                       {
     return m_validators->getSerializedValidatorList();
   }

◆ graceful_exit()

void cryptonote::core::graceful_exit ( )

tells the daemon to wind down operations and stop running

Currently this function raises SIGTERM, allowing the installed signal handlers to do the actual stopping.

Definition at line 2024 of file cryptonote_core.cpp.

   {
     raise(SIGTERM);
   }

Here is the caller graph for this function:

◆ handle_block_found()

bool cryptonote::core::handle_block_found	(	block &	b,
		block_verification_context &	bvc
	)

virtual

stores and relays a block found by a miner

Updates the miner's target block, attempts to store the found block in Blockchain, and – on success – relays that block to the network.

Parameters

b	the block found
bvc	returns the block verification flags

Returns: true if the block was added to the main chain, otherwise false

Implements cryptonote::i_miner_handler.

Definition at line 1370 of file cryptonote_core.cpp.

   {
     bvc = boost::value_initialized<block_verification_context>();
     m_miner.pause();
     std::vector<block_complete_entry> blocks;
     try
     {
       blocks.push_back(get_block_complete_entry(b, m_mempool));
     }
     catch (const std::exception &e)
     {
       m_miner.resume();
       return false;
     }
     std::vector<block> pblocks;
     if (!prepare_handle_incoming_blocks(blocks, pblocks))
     {
       MERROR("Block found, but failed to prepare to add");
       m_miner.resume();
       return false;
     }
     m_blockchain_storage.add_new_block(b, bvc);
     cleanup_handle_incoming_blocks(true);
  
     CHECK_AND_ASSERT_MES(!bvc.m_verification_failed, false, "Mined block failed verification");
     if(bvc.m_added_to_main_chain)
     {
       cryptonote_connection_context exclude_context = boost::value_initialized<cryptonote_connection_context>();
       NOTIFY_NEW_BLOCK::request arg = AUTO_VAL_INIT(arg);
       arg.current_blockchain_height = m_blockchain_storage.get_current_blockchain_height();
       std::vector<crypto::hash> missed_txs;
       std::vector<cryptonote::blobdata> txs;
       m_blockchain_storage.get_transactions_blobs(b.tx_hashes, txs, missed_txs);
       if(missed_txs.size() &&  m_blockchain_storage.get_block_id_by_height(get_block_height(b)) != get_block_hash(b))
       {
         LOG_PRINT_L1("Block found but, seems that reorganize just happened after that, do not relay this block");
         return true;
       }
       CHECK_AND_ASSERT_MES(txs.size() == b.tx_hashes.size() && !missed_txs.size(), false, "can't find some transactions in found block:" << get_block_hash(b) << " txs.size()=" << txs.size()
         << ", b.tx_hashes.size()=" << b.tx_hashes.size() << ", missed_txs.size()" << missed_txs.size());
  
       block_to_blob(b, arg.b.block);
       //pack transactions
       for(auto& tx:  txs)
         arg.b.txs.push_back(tx);
  
       m_pprotocol->relay_block(arg, exclude_context);
  
       if(m_fallback_to_pow) {
         m_miner.resume();
       }
     } else {
       update_miner_block_template();
       m_miner.resume();
     }
     return true;
   }

Here is the call graph for this function:

◆ handle_get_objects()

bool cryptonote::core::handle_get_objects	(	NOTIFY_REQUEST_GET_OBJECTS::request &	arg,
		NOTIFY_RESPONSE_GET_OBJECTS::request &	rsp,
		cryptonote_connection_context &	context
	)

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

Note: see Blockchain::handle_get_objects()

Parameters

context connection context associated with the request

Definition at line 1608 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.handle_get_objects(arg, rsp);
   }

Here is the call graph for this function:

◆ handle_incoming_block()

bool cryptonote::core::handle_incoming_block	(	const blobdata &	block_blob,
		const block *	b,
		block_verification_context &	bvc,
		bool	update_miner_blocktemplate = `true`
	)

handles an incoming block

periodic update to checkpoints is triggered here Attempts to add the block to the Blockchain and, on success, optionally updates the miner's block template.

Parameters

block_blob	the block to be added
block	the block to be added, or NULL
bvc	return-by-reference metadata context about the block's validity
update_miner_blocktemplate	whether or not to update the miner's block template

Returns: false if loading new checkpoints fails, or the block is not added, otherwise true

Definition at line 1468 of file cryptonote_core.cpp.

   {
     TRY_ENTRY();
  
     bvc = boost::value_initialized<block_verification_context>();
  
     if (!check_incoming_block_size(block_blob))
     {
       bvc.m_verification_failed = true;
       return false;
     }
  
     if (((size_t)-1) <= 0xffffffff && block_blob.size() >= 0x3fffffff)
       MWARNING("This block's size is " << block_blob.size() << ", closing on the 32 bit limit");
  
     // load json & DNS checkpoints every 10min/hour respectively,
     // and verify them with respect to what blocks we already have
     CHECK_AND_ASSERT_MES(update_checkpoints(), false, "One or more checkpoints loaded from json or dns conflicted with existing checkpoints.");
  
     block lb;
     if (!b)
     {
       crypto::hash block_hash;
       if(!parse_and_validate_block_from_blob(block_blob, lb, block_hash))
       {
         LOG_PRINT_L1("Failed to parse and validate new block");
         bvc.m_verification_failed = true;
         return false;
       }
       b = &lb;
     }
  
     add_new_block(*b, bvc);
  
     if(bvc.m_added_to_main_chain) {
       m_miner.resume();
  
       if(update_miner_blocktemplate)
         update_miner_block_template();
     }
  
     return true;
  
     CATCH_ENTRY_L0("core::handle_incoming_block()", false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_incoming_tx()

bool cryptonote::core::handle_incoming_tx	(	const blobdata &	tx_blob,
		tx_verification_context &	tvc,
		bool	keeped_by_block,
		bool	relayed,
		bool	do_not_relay
	)

handles an incoming transaction

Parses an incoming transaction and, if nothing is obviously wrong, passes it along to the transaction pool

Parameters

tx_blob	the tx to handle
tvc	metadata about the transaction's validity
keeped_by_block	if the transaction has been in a block
relayed	whether or not the transaction was relayed to us
do_not_relay	whether to prevent the transaction from being relayed

Returns: true if the transaction was accepted, false otherwise

Definition at line 1038 of file cryptonote_core.cpp.

   {
     std::vector<cryptonote::blobdata> tx_blobs;
     tx_blobs.push_back(tx_blob);
     std::vector<tx_verification_context> tvcv(1);
     bool r = handle_incoming_txs(tx_blobs, tvcv, keeped_by_block, relayed, do_not_relay);
     tvc = tvcv[0];
     return r;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_incoming_txs()

bool cryptonote::core::handle_incoming_txs	(	const std::vector< blobdata > &	tx_blobs,
		std::vector< tx_verification_context > &	tvc,
		bool	keeped_by_block,
		bool	relayed,
		bool	do_not_relay
	)

handles a list of incoming transactions

Parses incoming transactions and, if nothing is obviously wrong, passes them along to the transaction pool

Parameters

tx_blobs	the txs to handle
tvc	metadata about the transactions' validity
keeped_by_block	if the transactions have been in a block
relayed	whether or not the transactions were relayed to us
do_not_relay	whether to prevent the transactions from being relayed

Returns: true if the transactions were accepted, false otherwise

Definition at line 940 of file cryptonote_core.cpp.

   {
     TRY_ENTRY();
     CRITICAL_REGION_LOCAL(m_incoming_tx_lock);
  
     struct result { bool res; cryptonote::transaction tx; crypto::hash hash; };
     std::vector<result> results(tx_blobs.size());
  
     tvc.resize(tx_blobs.size());
     tools::threadpool& tpool = tools::threadpool::getInstance();
     tools::threadpool::waiter waiter;
     std::vector<blobdata>::const_iterator it = tx_blobs.begin();
     for (size_t i = 0; i < tx_blobs.size(); i++, ++it) {
       tpool.submit(&waiter, [&, i, it] {
         try
         {
           results[i].res = handle_incoming_tx_pre(*it, tvc[i], results[i].tx, results[i].hash, keeped_by_block, relayed, do_not_relay);
         }
         catch (const std::exception &e)
         {
           MERROR_VER("Exception in handle_incoming_tx_pre: " << e.what());
           tvc[i].m_verification_failed = true;
           results[i].res = false;
         }
       });
     }
     waiter.wait(&tpool);
     it = tx_blobs.begin();
     std::vector<bool> already_have(tx_blobs.size(), false);
     for (size_t i = 0; i < tx_blobs.size(); i++, ++it) {
       if (!results[i].res)
         continue;
       if(m_mempool.have_tx(results[i].hash))
       {
         LOG_PRINT_L2("tx " << results[i].hash << "already have transaction in tx_pool");
         already_have[i] = true;
       }
       else if(m_blockchain_storage.have_tx(results[i].hash))
       {
         LOG_PRINT_L2("tx " << results[i].hash << " already have transaction in blockchain");
         already_have[i] = true;
       }
       else
       {
         tpool.submit(&waiter, [&, i, it] {
           try
           {
             results[i].res = handle_incoming_tx_post(*it, tvc[i], results[i].tx, results[i].hash, keeped_by_block, relayed, do_not_relay);
           }
           catch (const std::exception &e)
           {
             MERROR_VER("Exception in handle_incoming_tx_post: " << e.what());
             tvc[i].m_verification_failed = true;
             results[i].res = false;
           }
         });
       }
     }
     waiter.wait(&tpool);
  
     std::vector<tx_verification_batch_info> tx_info;
     tx_info.reserve(tx_blobs.size());
     for (size_t i = 0; i < tx_blobs.size(); i++) {
       if (!results[i].res || already_have[i])
         continue;
       tx_info.push_back({&results[i].tx, results[i].hash, tvc[i], results[i].res});
     }
     if (!tx_info.empty())
       handle_incoming_tx_accumulated_batch(tx_info, keeped_by_block);
  
     bool ok = true;
     it = tx_blobs.begin();
     for (size_t i = 0; i < tx_blobs.size(); i++, ++it) {
       if (!results[i].res)
       {
         ok = false;
         continue;
       }
       if (keeped_by_block)
         get_blockchain_storage().on_new_tx_from_block(results[i].tx);
       if (already_have[i])
         continue;
  
       const size_t weight = get_transaction_weight(results[i].tx, it->size());
       ok &= add_new_tx(results[i].tx, results[i].hash, tx_blobs[i], weight, tvc[i], keeped_by_block, relayed, do_not_relay);
       if(tvc[i].m_verification_failed)
       {MERROR_VER("Transaction verification failed: " << results[i].hash);}
       else if(tvc[i].m_verification_impossible)
       {MERROR_VER("Transaction verification impossible: " << results[i].hash);}
  
       if(tvc[i].m_added_to_pool)
         MDEBUG("tx added: " << results[i].hash);
     }
     return ok;
  
     CATCH_ENTRY_L0("core::handle_incoming_txs()", false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ have_block()

bool cryptonote::core::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

Note: see Blockchain::have_block

Definition at line 1550 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.have_block(id);
   }

Here is the call graph for this function:

◆ init()

bool cryptonote::core::init	(	const boost::program_options::variables_map &	vm,
		const test_options *	test_options = `NULL`,
		const GetCheckpointsCallback &	get_checkpoints = `nullptr`
	)

initializes the core as needed

This function initializes the transaction pool, the Blockchain, and a miner instance with parameters given on the command line (or defaults)

Parameters

vm	command line parameters
test_options	configuration options for testing
get_checkpoints	if set, will be called to get checkpoints data, must return checkpoints data pointer and size or nullptr if there ain't any checkpoints for specific network type

Returns: false if one of the init steps fails, otherwise true

Definition at line 497 of file cryptonote_core.cpp.

   {
     start_time = std::time(nullptr);
  
     const bool regtest = command_line::get_arg(vm, arg_regtest_on);
     if (test_options != NULL || regtest)
     {
       m_nettype = FAKECHAIN;
     }
  
     m_fallback_to_pow = command_line::get_arg(vm, arg_fallback_to_pow);
     m_fallback_to_pow_checkpoint_height = command_line::get_arg(vm, arg_fallback_to_pow_checkpoint_height);
     m_fallback_to_pow_checkpoint_hash = command_line::get_arg(vm, arg_fallback_to_pow_checkpoint_hash);
  
     bool r = handle_command_line(vm);
  
     std::string db_type = command_line::get_arg(vm, cryptonote::arg_db_type);
     std::string db_sync_mode = command_line::get_arg(vm, cryptonote::arg_db_sync_mode);
     bool db_salvage = command_line::get_arg(vm, cryptonote::arg_db_salvage) != 0;
     bool fast_sync = command_line::get_arg(vm, arg_fast_block_sync) != 0;
     uint64_t blocks_threads = command_line::get_arg(vm, arg_prep_blocks_threads);
     std::string check_updates_string = command_line::get_arg(vm, arg_check_updates);
     size_t max_txpool_weight = command_line::get_arg(vm, arg_max_txpool_weight);
     bool prune_blockchain = command_line::get_arg(vm, arg_prune_blockchain);
     std::string validator_key = command_line::get_arg(vm, arg_validator_key);
  
     bool is_validator_key_valid = std::count_if(validator_key.begin(), validator_key.end(), [](int c) {return !std::isxdigit(c);}) == 0;
     if(!is_validator_key_valid || validator_key.size() % 2 != 0) {
       validator_key.clear();
     }
  
     boost::filesystem::path folder(m_config_folder);
     if (m_nettype == FAKECHAIN)
       folder /= "fake";
  
     // make sure the data directory exists, and try to lock it
     CHECK_AND_ASSERT_MES (boost::filesystem::exists(folder) || boost::filesystem::create_directories(folder), false,
       std::string("Failed to create directory ").append(folder.string()).c_str());
  
     // check for blockchain.bin
     try
     {
       const boost::filesystem::path old_files = folder;
       if (boost::filesystem::exists(old_files / "blockchain.bin"))
       {
         MWARNING("Found old-style blockchain.bin in " << old_files.string());
         MWARNING("Electroneum now uses a new format. You can either remove blockchain.bin to start syncing");
         MWARNING("the blockchain anew, or use electroneum-blockchain-export and electroneum-blockchain-import to");
         MWARNING("convert your existing blockchain.bin to the new format. See README.md for instructions.");
         return false;
       }
     }
     // folder might not be a directory, etc, etc
     catch (...) { }
  
     std::unique_ptr<BlockchainDB> db(new_db(db_type));
     if (db == NULL)
     {
       LOG_ERROR("Attempted to use non-existent database type");
       return false;
     }
  
     folder /= db->get_db_name();
     MGINFO("Loading blockchain from folder " << folder.string() << " ...");
  
     const std::string filename = folder.string();
     // default to fast:async:1 if overridden
     blockchain_db_sync_mode sync_mode = db_defaultsync;
     bool sync_on_blocks = true;
     uint64_t sync_threshold = 1;
  
     if (m_nettype == FAKECHAIN)
     {
       // reset the db by removing the database file before opening it
       if (!db->remove_data_file(filename))
       {
         MERROR("Failed to remove data file in " << filename);
         return false;
       }
     }
  
     try
     {
       uint64_t db_flags = 0;
  
       std::vector<std::string> options;
       boost::trim(db_sync_mode);
       boost::split(options, db_sync_mode, boost::is_any_of(" :"));
       const bool db_sync_mode_is_default = command_line::is_arg_defaulted(vm, cryptonote::arg_db_sync_mode);
  
       for(const auto &option : options)
         MDEBUG("option: " << option);
  
       // default to fast:async:1
       uint64_t DEFAULT_FLAGS = DBF_FAST;
  
       if(options.size() == 0)
       {
         // default to fast:async:1
         db_flags = DEFAULT_FLAGS;
       }
  
       bool safemode = false;
       if(options.size() >= 1)
       {
         if(options[0] == "safe")
         {
           safemode = true;
           db_flags = DBF_SAFE;
           sync_mode = db_sync_mode_is_default ? db_defaultsync : db_nosync;
         }
         else if(options[0] == "fast")
         {
           db_flags = DBF_FAST;
           sync_mode = db_sync_mode_is_default ? db_defaultsync : db_async;
         }
         else if(options[0] == "fastest")
         {
           db_flags = DBF_FASTEST;
           sync_threshold = 1000; // default to fastest:async:1000
           sync_mode = db_sync_mode_is_default ? db_defaultsync : db_async;
         }
         else
           db_flags = DEFAULT_FLAGS;
       }
  
       if(options.size() >= 2 && !safemode)
       {
         if(options[1] == "sync")
           sync_mode = db_sync_mode_is_default ? db_defaultsync : db_sync;
         else if(options[1] == "async")
           sync_mode = db_sync_mode_is_default ? db_defaultsync : db_async;
       }
  
       if(options.size() >= 3 && !safemode)
       {
         char *endptr;
         uint64_t threshold = strtoull(options[2].c_str(), &endptr, 0);
         if (*endptr == '\0' || !strcmp(endptr, "blocks"))
         {
           sync_on_blocks = true;
           sync_threshold = threshold;
         }
         else if (!strcmp(endptr, "bytes"))
         {
           sync_on_blocks = false;
           sync_threshold = threshold;
         }
         else
         {
           LOG_ERROR("Invalid db sync mode: " << options[2]);
           return false;
         }
       }
  
       if (db_salvage)
         db_flags |= DBF_SALVAGE;
  
       db->open(filename, db_flags);
       if(!db->m_open)
         return false;
     }
     catch (const DB_ERROR& e)
     {
       LOG_ERROR("Error opening database: " << e.what());
       return false;
     }
  
     m_blockchain_storage.set_user_options(blocks_threads,
         sync_on_blocks, sync_threshold, sync_mode, fast_sync, validator_key);
  
     try
     {
       if (!command_line::is_arg_defaulted(vm, arg_block_notify))
         m_blockchain_storage.set_block_notify(std::shared_ptr<tools::Notify>(new tools::Notify(command_line::get_arg(vm, arg_block_notify).c_str())));
     }
     catch (const std::exception &e)
     {
       MERROR("Failed to parse block notify spec: " << e.what());
     }
  
     try
     {
       if (!command_line::is_arg_defaulted(vm, arg_reorg_notify))
         m_blockchain_storage.set_reorg_notify(std::shared_ptr<tools::Notify>(new tools::Notify(command_line::get_arg(vm, arg_reorg_notify).c_str())));
     }
     catch (const std::exception &e)
     {
       MERROR("Failed to parse reorg notify spec: " << e.what());
     }
  
     try
     {
       if (!command_line::is_arg_defaulted(vm, arg_block_rate_notify))
         m_block_rate_notify.reset(new tools::Notify(command_line::get_arg(vm, arg_block_rate_notify).c_str()));
     }
     catch (const std::exception &e)
     {
       MERROR("Failed to parse block rate notify spec: " << e.what());
     }
  
     const std::pair<uint8_t, uint64_t> regtest_hard_forks[3] = {std::make_pair(1, 0), std::make_pair(Blockchain::get_hard_fork_heights(MAINNET).back().version, 1), std::make_pair(0, 0)};
     const cryptonote::test_options regtest_test_options = {
       regtest_hard_forks,
       0
     };
     const difficulty_type fixed_difficulty = command_line::get_arg(vm, arg_fixed_difficulty);
     const bool ignore_bsig = command_line::get_arg(vm, arg_skip_block_sig_verification);
  
     r = m_blockchain_storage.init(db.release(), m_nettype, m_offline, regtest ? &regtest_test_options : test_options, fixed_difficulty, get_checkpoints, ignore_bsig, m_fallback_to_pow);
  
     r = m_mempool.init(max_txpool_weight);
     CHECK_AND_ASSERT_MES(r, false, "Failed to initialize memory pool");
  
     // now that we have a valid m_blockchain_storage, we can clean out any
     // transactions in the pool that do not conform to the current fork
     m_mempool.validate(m_blockchain_storage.get_current_hard_fork_version());
  
     bool show_time_stats = command_line::get_arg(vm, arg_show_time_stats) != 0;
     m_blockchain_storage.set_show_time_stats(show_time_stats);
     CHECK_AND_ASSERT_MES(r, false, "Failed to initialize blockchain storage");
  
     block_sync_size = command_line::get_arg(vm, arg_block_sync_size);
  
     MGINFO("Loading checkpoints");
  
     // load json & DNS checkpoints, and verify them
     // with respect to what blocks we already have
     CHECK_AND_ASSERT_MES(update_checkpoints(), false, "One or more checkpoints loaded from json or dns conflicted with existing checkpoints.");
  
    // DNS versions checking
     if (check_updates_string == "disabled")
       check_updates_level = UPDATES_DISABLED;
     else if (check_updates_string == "notify")
       check_updates_level = UPDATES_NOTIFY;
     else if (check_updates_string == "download")
       check_updates_level = UPDATES_DOWNLOAD;
     else if (check_updates_string == "update")
       check_updates_level = UPDATES_UPDATE;
     else {
       MERROR("Invalid argument to --dns-versions-check: " << check_updates_string);
       return false;
     }
  
     check_updates_level = UPDATES_DISABLED;
  
     r = m_miner.init(vm, m_nettype, m_fallback_to_pow);
     CHECK_AND_ASSERT_MES(r, false, "Failed to initialize miner instance");
  
     if (prune_blockchain)
     {
       // display a message if the blockchain is not pruned yet
       if (!m_blockchain_storage.get_blockchain_pruning_seed())
       {
         MGINFO("Pruning blockchain...");
         CHECK_AND_ASSERT_MES(m_blockchain_storage.prune_blockchain(), false, "Failed to prune blockchain");
       }
       else
       {
         CHECK_AND_ASSERT_MES(m_blockchain_storage.update_blockchain_pruning(), false, "Failed to update blockchain pruning");
       }
     }
  
     if(!m_fallback_to_pow) {
       m_validators = std::unique_ptr<electroneum::basic::Validators>(new electroneum::basic::Validators(m_blockchain_storage.get_db(), m_pprotocol, m_nettype == TESTNET));
       m_blockchain_storage.set_validators_list_instance(m_validators);
  
       if(m_blockchain_storage.get_current_blockchain_height() >= ((m_nettype == TESTNET ? 446674 : 589169) - 720 )) { //V8 Height - 1 day
         m_validators->enable();
       }
     }
  
     return load_state_data();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_options()

void cryptonote::core::init_options ( boost::program_options::options_description & desc )

static

adds command line options to the given options set

As of now, there are no command line options specific to core, so this function simply returns.

Parameters

desc	return-by-reference the command line options set to add to

Definition at line 346 of file cryptonote_core.cpp.

   {
     command_line::add_arg(desc, arg_data_dir);
  
     command_line::add_arg(desc, arg_test_drop_download);
     command_line::add_arg(desc, arg_test_drop_download_height);
  
     command_line::add_arg(desc, arg_testnet_on);
     command_line::add_arg(desc, arg_stagenet_on);
     command_line::add_arg(desc, arg_regtest_on);
     command_line::add_arg(desc, arg_fixed_difficulty);
     command_line::add_arg(desc, arg_skip_block_sig_verification);
     command_line::add_arg(desc, arg_dns_checkpoints);
     command_line::add_arg(desc, arg_prep_blocks_threads);
     command_line::add_arg(desc, arg_fast_block_sync);
     command_line::add_arg(desc, arg_show_time_stats);
     command_line::add_arg(desc, arg_block_sync_size);
     command_line::add_arg(desc, arg_check_updates);
     command_line::add_arg(desc, arg_fluffy_blocks);
     command_line::add_arg(desc, arg_no_fluffy_blocks);
     command_line::add_arg(desc, arg_test_dbg_lock_sleep);
     command_line::add_arg(desc, arg_offline);
     command_line::add_arg(desc, arg_disable_dns_checkpoints);
     command_line::add_arg(desc, arg_block_download_max_size);
     command_line::add_arg(desc, arg_max_txpool_weight);
     command_line::add_arg(desc, arg_pad_transactions);
     command_line::add_arg(desc, arg_block_notify);
     command_line::add_arg(desc, arg_prune_blockchain);
     command_line::add_arg(desc, arg_reorg_notify);
     command_line::add_arg(desc, arg_block_rate_notify);
     command_line::add_arg(desc, arg_validator_key);
     command_line::add_arg(desc, arg_fallback_to_pow);
     command_line::add_arg(desc, arg_fallback_to_pow_checkpoint_height);
     command_line::add_arg(desc, arg_fallback_to_pow_checkpoint_hash);
  
     miner::init_options(desc);
     BlockchainDB::init_options(desc);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_key_image_spent()

bool cryptonote::core::is_key_image_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

Note: see Blockchain::have_tx_keyimg_as_spent

Definition at line 1130 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.have_tx_keyimg_as_spent(key_image);
   }

Here is the call graph for this function:

◆ is_update_available()

bool cryptonote::core::is_update_available ( ) const

inline

check whether an update is known to be available or not

This does not actually trigger a check, but returns the result of the last check

Returns: whether an update is known to be available or not

Definition at line 796 of file cryptonote_core.h.

796 { return m_update_available; }

Here is the caller graph for this function:

◆ isValidatorsListValid()

bool cryptonote::core::isValidatorsListValid ( )

get Validators List state

Returns: true if valid, false if invalid or expired

Definition at line 327 of file cryptonote_core.cpp.

                                    {
     return m_validators->isValid();
   }

◆ offline()

bool cryptonote::core::offline ( ) const

inline

get whether the core is running offline

Returns: whether the core is running offline

Definition at line 824 of file cryptonote_core.h.

824 { return m_offline; }

Here is the caller graph for this function:

◆ on_idle()

bool cryptonote::core::on_idle ( )

calls various idle routines

Note: see miner::on_idle and tx_memory_pool::on_idle

Returns: true

Definition at line 1634 of file cryptonote_core.cpp.

   {
     if(!m_starter_message_showed)
     {
       std::string main_message;
       if (m_offline)
         main_message = "The daemon is running offline and will not attempt to sync to the Electroneum network.";
       else
         main_message = "The daemon will start synchronizing with the network. This may take a long time to complete.";
       MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
         << main_message << ENDL
         << ENDL
         << "You can set the level of process detailization through \"set_log <level|categories>\" command," << ENDL
         << "where <level> is between 0 (no details) and 4 (very verbose), or custom category based levels (eg, *:WARNING)." << ENDL
         << ENDL
         << "Use the \"help\" command to see the list of available commands." << ENDL
         << "Use \"help <command>\" to see a command's documentation." << ENDL
         << "**********************************************************************" << ENDL);
       m_starter_message_showed = true;
     }
     //Don't moan about forks for now, but keep implementation around incase we need to use it at a later stage
     //m_fork_moaner.do_call(boost::bind(&core::check_fork_time, this));
     m_txpool_auto_relayer.do_call(boost::bind(&core::relay_txpool_transactions, this));
     m_check_updates_interval.do_call(boost::bind(&core::check_updates, this));
     m_check_disk_space_interval.do_call(boost::bind(&core::check_disk_space, this));
     m_block_rate_interval.do_call(boost::bind(&core::check_block_rate, this));
     m_blockchain_pruning_interval.do_call(boost::bind(&core::update_blockchain_pruning, this));
     m_miner.on_idle();
     m_mempool.on_idle();
  
     if(!m_fallback_to_pow) {
       m_validators->on_idle();
     }
  
     return true;
   }

Here is the call graph for this function:

◆ on_synchronized()

void cryptonote::core::on_synchronized ( )

Note: see miner::on_synchronized

Definition at line 1428 of file cryptonote_core.cpp.

   {
     m_miner.on_synchronized();
   }

Here is the call graph for this function:

◆ on_transaction_relayed()

void cryptonote::core::on_transaction_relayed ( const cryptonote::blobdata & tx )

virtual

called when a transaction is relayed

Definition at line 1293 of file cryptonote_core.cpp.

   {
     std::vector<std::pair<crypto::hash, cryptonote::blobdata>> txs;
     cryptonote::transaction tx;
     crypto::hash tx_hash;
     if (!parse_and_validate_tx_from_blob(tx_blob, tx, tx_hash))
     {
       LOG_ERROR("Failed to parse relayed transaction");
       return;
     }
     txs.push_back(std::make_pair(tx_hash, std::move(tx_blob)));
     m_mempool.set_relayed(txs);
   }

Here is the call graph for this function:

◆ pad_transactions()

bool cryptonote::core::pad_transactions ( ) const

inline

get whether transaction relay should be padded

Returns: whether transaction relay should be padded

Definition at line 810 of file cryptonote_core.h.

810 { return m_pad_transactions; }

◆ pause_mine()

void cryptonote::core::pause_mine ( )

Note: see miner::pause

Definition at line 1347 of file cryptonote_core.cpp.

   {
     m_miner.pause();
   }

Here is the call graph for this function:

◆ pool_has_tx()

bool cryptonote::core::pool_has_tx ( const crypto::hash & txid ) const

checks if the pool has a transaction with the given hash

Parameters

id	the hash to look for

Returns: true if the transaction is in the pool, otherwise false

Note: see tx_memory_pool::have_tx

Definition at line 1588 of file cryptonote_core.cpp.

   {
     return m_mempool.have_tx(id);
   }

Here is the call graph for this function:

◆ prepare_handle_incoming_blocks()

bool cryptonote::core::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

Note: see Blockchain::prepare_handle_incoming_blocks

Definition at line 1444 of file cryptonote_core.cpp.

   {
     m_incoming_tx_lock.lock();
     if (!m_blockchain_storage.prepare_handle_incoming_blocks(blocks_entry, blocks))
     {
       cleanup_handle_incoming_blocks(false);
       return false;
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_pool()

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

get a string containing human-readable pool information

Parameters

short_format whether to use a shortened format for the info

Returns: the string

Note: see tx_memory_pool::print_pool

Definition at line 1623 of file cryptonote_core.cpp.

   {
     return m_mempool.print_pool(short_format);
   }

Here is the call graph for this function:

◆ prune_blockchain()

bool cryptonote::core::prune_blockchain ( uint32_t pruning_seed = 0 )

prune the blockchain

Parameters

pruning_seed the seed to use to prune the chain (0 for default, highly recommended)

Returns: true iff success

Definition at line 1979 of file cryptonote_core.cpp.

   {
     return get_blockchain_storage().prune_blockchain(pruning_seed);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resume_mine()

void cryptonote::core::resume_mine ( )

Note: see miner::resume

Definition at line 1352 of file cryptonote_core.cpp.

   {
     m_miner.resume();
   }

Here is the call graph for this function:

◆ safesyncmode()

void cryptonote::core::safesyncmode ( const bool onoff )

Put DB in safe sync mode.

2note see Blockchain::safesyncmode

Definition at line 1433 of file cryptonote_core.cpp.

   {
     m_blockchain_storage.safesyncmode(onoff);
   }

Here is the call graph for this function:

◆ set_block_cumulative_difficulty()

void cryptonote::core::set_block_cumulative_difficulty	(	uint64_t	height,
		difficulty_type	diff
	)

Note: see Blockchain::set_block_cumulative_difficulty

Definition at line 1535 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.get_db().set_block_cumulative_difficulty(height, diff);
   }

Here is the call graph for this function:

◆ set_checkpoints()

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

assign a set of blockchain checkpoint hashes

Parameters

chk_pts the set of checkpoints to assign

Note: see Blockchain::set_checkpoints()

Definition at line 275 of file cryptonote_core.cpp.

   {
     m_blockchain_storage.set_checkpoints(std::move(chk_pts));
   }

Here is the call graph for this function:

◆ set_checkpoints_file_path()

void cryptonote::core::set_checkpoints_file_path ( const std::string & path )

set the file path to read from when loading checkpoints

Parameters

path	the path to set ours as

Definition at line 280 of file cryptonote_core.cpp.

   {
     m_checkpoints_path = path;
   }

◆ set_cryptonote_protocol()

void cryptonote::core::set_cryptonote_protocol ( i_cryptonote_protocol * pprotocol )

set the pointer to the cryptonote protocol object to use

Parameters

pprotocol the pointer to set ours as

Definition at line 267 of file cryptonote_core.cpp.

   {
     if(pprotocol)
       m_pprotocol = pprotocol;
     else
       m_pprotocol = &m_protocol_stub;
   }

Here is the caller graph for this function:

◆ set_enforce_dns_checkpoints()

void cryptonote::core::set_enforce_dns_checkpoints ( bool enforce_dns )

set whether or not we enforce DNS checkpoints

Parameters

enforce_dns enforce DNS checkpoints or not

Definition at line 285 of file cryptonote_core.cpp.

   {
     m_blockchain_storage.set_enforce_dns_checkpoints(enforce_dns);
   }

Here is the call graph for this function:

◆ set_genesis_block()

bool cryptonote::core::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

Note: see Blockchain::reset_and_set_genesis_block

Definition at line 772 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.reset_and_set_genesis_block(b);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_target_blockchain_height()

void cryptonote::core::set_target_blockchain_height ( uint64_t target_blockchain_height )

sets the target blockchain height

Parameters

target_blockchain_height the height to set

Definition at line 1957 of file cryptonote_core.cpp.

   {
     m_target_blockchain_height = target_blockchain_height;
   }

◆ set_validator_key()

bool cryptonote::core::set_validator_key ( std::string key )

set validator key

Parameters

key	key to set as new validator key

Returns: whether this new key was set or not

Definition at line 1989 of file cryptonote_core.cpp.

                                             {
     bool is_validator_key_valid = std::count_if(key.begin(), key.end(), [](int c) {return !std::isxdigit(c);}) == 0;
     if(!is_validator_key_valid || key.size() % 2 != 0) {
       return false;
     }
  
     m_miner.pause();
     m_blockchain_storage.set_validator_key(key);
     m_miner.resume();
  
     return true;
   }

Here is the call graph for this function:

◆ set_validators_list()

electroneum::basic::list_update_outcome cryptonote::core::set_validators_list	(	std::string	v_list,
		bool	isEmergencyUpdate
	)

set the list of validators according to the serialized string passed in as parameter

Parameters

v_list serialized validators list string

Returns: true if successfull

Definition at line 323 of file cryptonote_core.cpp.

                                                                                                         {
     return m_validators->setValidatorsList(v_list, true, isEmergencyUpdate);
   }

◆ sign_message()

std::string cryptonote::core::sign_message	(	std::string	sk,
		std::string	msg
	)

Definition at line 2007 of file cryptonote_core.cpp.

                                                           {
     std::string b_str = crypto::sign_message(msg, sk);
     return boost::algorithm::hex(b_str);
   }

Here is the call graph for this function:

◆ stop()

void cryptonote::core::stop ( )

stops the daemon running

Note: see graceful_exit()

Definition at line 331 of file cryptonote_core.cpp.

   {
     m_miner.stop();
     m_blockchain_storage.cancel();
  
     tools::download_async_handle handle;
     {
       boost::lock_guard<boost::mutex> lock(m_update_mutex);
       handle = m_update_download;
       m_update_download = 0;
     }
     if (handle)
       tools::download_cancel(handle);
   }

Here is the call graph for this function:

◆ test_drop_download()

void cryptonote::core::test_drop_download ( )

sets to drop blocks downloaded (for testing)

Definition at line 791 of file cryptonote_core.cpp.

   {
     m_test_drop_download = false;
   }

◆ test_drop_download_height()

void cryptonote::core::test_drop_download_height ( uint64_t height )

sets to drop blocks downloaded below a certain height

Parameters

height height below which to drop blocks

Definition at line 796 of file cryptonote_core.cpp.

   {
     m_test_drop_download_height = height;
   }

◆ update_blockchain_pruning()

bool cryptonote::core::update_blockchain_pruning ( )

incrementally prunes blockchain

Returns: true on success, false otherwise

Definition at line 1947 of file cryptonote_core.cpp.

   {
     return m_blockchain_storage.update_blockchain_pruning();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_checkpoints()

bool cryptonote::core::update_checkpoints ( )

tells the Blockchain to update its checkpoints

This function will check if enough time has passed since the last time checkpoints were updated and tell the Blockchain to update its checkpoints if it is time. If updating checkpoints fails, the daemon is told to shut down.

Note: see Blockchain::update_checkpoints()

Definition at line 290 of file cryptonote_core.cpp.

   {
     if (m_nettype != MAINNET || m_disable_dns_checkpoints) return true;
  
     if (m_checkpoints_updating.test_and_set()) return true;
  
     bool res = true;
     if (time(NULL) - m_last_dns_checkpoints_update >= 3600)
     {
       res = m_blockchain_storage.update_checkpoints(m_checkpoints_path, true);
       m_last_dns_checkpoints_update = time(NULL);
       m_last_json_checkpoints_update = time(NULL);
     }
     else if (time(NULL) - m_last_json_checkpoints_update >= 600)
     {
       res = m_blockchain_storage.update_checkpoints(m_checkpoints_path, false);
       m_last_json_checkpoints_update = time(NULL);
     }
  
     m_checkpoints_updating.clear();
  
     // if anything fishy happened getting new checkpoints, bring down the house
     if (!res)
     {
       graceful_exit();
     }
     return res;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ core()

Member Function Documentation

◆ are_key_images_spent()

◆ are_key_images_spent_in_pool()

◆ check_blockchain_pruning()

◆ check_incoming_block_size()

◆ cleanup_handle_incoming_blocks()

◆ deinit()

◆ disable_dns_checkpoints()

◆ find_blockchain_supplement() [1/2]

◆ find_blockchain_supplement() [2/2]

◆ fluffy_blocks_enabled()

◆ generate_ed25519_keypair()

◆ get_address_batch_history()

◆ get_alternative_blocks()

◆ get_alternative_blocks_count()

◆ get_balance()

◆ get_block_by_hash()

◆ get_block_cumulative_difficulty()

◆ get_block_id_by_height()

◆ get_block_sync_size()

◆ get_block_template() [1/2]

◆ get_block_template() [2/2]

◆ get_blockchain_pruning_seed()

◆ get_blockchain_storage() [1/2]

◆ get_blockchain_storage() [2/2]

◆ get_blockchain_top()

◆ get_blockchain_total_transactions()

◆ get_blocks() [1/4]

◆ get_blocks() [2/4]

◆ get_blocks() [3/4]

◆ get_blocks() [4/4]

◆ get_coinbase_tx_sum()

◆ get_current_blockchain_height()

◆ get_earliest_ideal_height_for_version()

◆ get_free_space()

◆ get_hard_fork_version()

◆ get_ideal_hard_fork_version() [1/2]

◆ get_ideal_hard_fork_version() [2/2]

◆ get_miner() [1/2]

◆ get_miner() [2/2]

◆ get_nettype()

◆ get_output_distribution()

◆ get_outs()

◆ get_pool_for_rpc()

◆ get_pool_transaction()

◆ get_pool_transaction_hashes()

◆ get_pool_transaction_stats()

◆ get_pool_transactions()

◆ get_pool_transactions_and_spent_keys_info()

◆ get_pool_transactions_count()

◆ get_protocol()

◆ get_short_chain_history()

◆ get_split_transactions_blobs()

◆ get_start_time()

◆ get_stat_info()

◆ get_tail_id()

◆ get_target_blockchain_height()

◆ get_test_drop_download()

◆ get_test_drop_download_height()

◆ get_transactions() [1/2]

◆ get_transactions() [2/2]

◆ get_tx_outputs_gindexs() [1/2]

◆ get_tx_outputs_gindexs() [2/2]

◆ get_txpool_backlog()

◆ get_validators_list()

◆ graceful_exit()

◆ handle_block_found()

◆ handle_get_objects()

◆ handle_incoming_block()

◆ handle_incoming_tx()

◆ handle_incoming_txs()

◆ have_block()

◆ init()

◆ init_options()