cryptonote::core Class Reference

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
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
bool	on_idle ()
	calls various idle routines
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
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
bool	handle_incoming_block (const blobdata &block_blob, const block *b, block_verification_context &bvc, bool update_miner_blocktemplate=true)
	handles an incoming block
bool	prepare_handle_incoming_blocks (const std::vector< block_complete_entry > &blocks_entry, std::vector< block > &blocks)
	performs some preprocessing on a group of incoming blocks to speed up verification
bool	cleanup_handle_incoming_blocks (bool force_sync=false)
	incoming blocks post-processing, cleanup, and disk sync
bool	check_incoming_block_size (const blobdata &block_blob) const
	check the size of a block against the current maximum
i_cryptonote_protocol *	get_protocol ()
	get the cryptonote protocol instance
virtual bool	handle_block_found (block &b, block_verification_context &bvc)
	stores and relays a block found by a miner
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
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
miner &	get_miner ()
	gets the miner instance
const miner &	get_miner () const
	gets the miner instance (const)
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
bool	set_genesis_block (const block &b)
	clears the blockchain and starts a new one
bool	deinit ()
	performs safe shutdown steps for core and core components
void	test_drop_download ()
	sets to drop blocks downloaded (for testing)
void	test_drop_download_height (uint64_t height)
	sets to drop blocks downloaded below a certain height
bool	get_test_drop_download () const
	gets whether or not to drop blocks (for testing)
bool	get_test_drop_download_height () const
	gets whether or not to drop blocks
uint64_t	get_current_blockchain_height () const
	get the current height of the blockchain
void	get_blockchain_top (uint64_t &height, crypto::hash &top_id) const
	get the hash and height of the most recent block
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
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
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
crypto::hash	get_block_id_by_height (uint64_t height) const
	gets a block's hash given a height
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
bool	get_alternative_blocks (std::vector< block > &blocks) const
	compiles a list of all blocks stored as alternative chains
size_t	get_alternative_blocks_count () const
	returns the number of alternative blocks stored
void	set_cryptonote_protocol (i_cryptonote_protocol *pprotocol)
	set the pointer to the cryptonote protocol object to use
void	set_checkpoints (checkpoints &&chk_pts)
	assign a set of blockchain checkpoint hashes
void	set_checkpoints_file_path (const std::string &path)
	set the file path to read from when loading checkpoints
void	set_enforce_dns_checkpoints (bool enforce_dns)
	set whether or not we enforce DNS checkpoints
void	disable_dns_checkpoints (bool disable=true)
	set whether or not to enable or disable DNS checkpoints
bool	pool_has_utxo_as_spent (const txin_to_key_public &in) const
	get a summary statistics of all transaction hashes in the pool
bool	pool_has_tx (const crypto::hash &txid) const
	checks if the pool has a transaction with the given hash
bool	get_pool_transactions (std::vector< transaction > &txs, bool include_unrelayed_txes=true) const
	get a list of all transactions in the pool
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
bool	get_pool_transaction_stats (struct txpool_stats &stats, bool include_unrelayed_txes=true) const
	get a list of all transactions in the pool
bool	get_pool_transaction (const crypto::hash &id, cryptonote::blobdata &tx) const
	get a specific transaction from the pool
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
size_t	get_pool_transactions_count () const
	get the total number of transactions in the pool
size_t	get_blockchain_total_transactions () const
	gets the total number of transactions on the main chain
bool	have_block (const crypto::hash &id) const
	checks if a block is known about with a given hash
bool	get_short_chain_history (std::list< crypto::hash > &ids) const
	gets the hashes for a subset of the blockchain
bool	find_blockchain_supplement (const std::list< crypto::hash > &qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request &resp) const
	get recent block hashes for a foreign chain
bool	find_blockchain_supplement (const uint64_t req_start_block, const std::list< crypto::hash > &qblock_ids, std::vector< std::pair< std::pair< cryptonote::blobdata, crypto::hash >, std::vector< std::pair< crypto::hash, cryptonote::blobdata > > > > &blocks, uint64_t &total_height, uint64_t &start_height, bool pruned, bool get_miner_tx_hash, size_t max_count) const
bool	get_stat_info (core_stat_info &st_inf) const
	gets some stats about the daemon
bool	get_tx_outputs_gindexs (const crypto::hash &tx_id, std::vector< uint64_t > &indexs) const
	gets the global indices for outputs from a given transaction
bool	get_tx_outputs_gindexs (const crypto::hash &tx_id, size_t n_txes, std::vector< std::vector< uint64_t > > &indexs) const
crypto::hash	get_tail_id () const
	get the hash of the most recent block on the blockchain
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
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
void	pause_mine ()
void	resume_mine ()
Blockchain &	get_blockchain_storage ()
	gets the Blockchain instance
const Blockchain &	get_blockchain_storage () const
	gets the Blockchain instance (const)
std::string	print_pool (bool short_format) const
	get a string containing human-readable pool information
void	on_synchronized ()
void	safesyncmode (const bool onoff)
	Put DB in safe sync mode.
void	set_target_blockchain_height (uint64_t target_blockchain_height)
	sets the target blockchain height
uint64_t	get_target_blockchain_height () const
	gets the target blockchain height
uint8_t	get_ideal_hard_fork_version () const
	returns the newest hardfork version known to the blockchain
uint8_t	get_ideal_hard_fork_version (uint64_t height) const
	return the ideal hard fork version for a given block height
uint8_t	get_hard_fork_version (uint64_t height) const
	return the hard fork version for a given block height
uint64_t	get_earliest_ideal_height_for_version (uint8_t version) const
	return the earliest block a given version may activate
std::time_t	get_start_time () const
	gets start_time
bool	update_checkpoints ()
	tells the Blockchain to update its checkpoints
std::string	get_validators_list ()
	Get a serialized representation of the list of validators.
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
bool	isValidatorsListValid ()
	get Validators List state
void	graceful_exit ()
	tells the daemon to wind down operations and stop running
void	stop ()
	stops the daemon running
bool	is_key_image_spent (const crypto::key_image &key_im) const
	check if a key image is already spent on the blockchain
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
bool	utxo_nonexistant (const std::vector< txin_to_key_public > &public_outputs, std::vector< bool > &spent) const
	check if multiple public outputs are found in the utxo database or not
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
size_t	get_block_sync_size (uint64_t height) const
	get the number of blocks to sync in one go
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
network_type	get_nettype () const
	get the network type we're on
bool	is_update_available () const
	check whether an update is known to be available or not
bool	fluffy_blocks_enabled () const
	get whether fluffy blocks are enabled
bool	pad_transactions () const
	get whether transaction relay should be padded
uint64_t	get_free_space () const
	get free disk space on the blockchain partition
bool	offline () const
	get whether the core is running offline
uint32_t	get_blockchain_pruning_seed () const
	get the blockchain pruning seed
bool	prune_blockchain (uint32_t pruning_seed=0)
	prune the blockchain
bool	update_blockchain_pruning ()
	incrementally prunes blockchain
bool	check_blockchain_pruning ()
	checks the blockchain pruning if enabled
bool	set_validator_key (std::string key)
	set validator key
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)
std::vector< address_txs >	get_addr_tx_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

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 1174 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;
  }

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 1204 of file cryptonote_core.cpp.

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

check_blockchain_pruning()

bool cryptonote::core::check_blockchain_pruning

(

)

checks the blockchain pruning if enabled

Returns

true on success, false otherwise

Definition at line 2006 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.check_blockchain_pruning();
  }

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 1565 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 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 1505 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 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 787 of file cryptonote_core.cpp.

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

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.

{ m_disable_dns_checkpoints = disable; }

Here is the caller graph for this function:

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 1366 of file cryptonote_core.cpp.

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

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 1371 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);
  }

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 824 of file cryptonote_core.h.

{ return m_fluffy_blocks_enabled; }

generate_ed25519_keypair()

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

(

)

Definition at line 2056 of file cryptonote_core.cpp.

                                                      {
    return crypto::create_ed25519_keypair();
  }

Here is the call graph for this function:

get_addr_tx_batch_history()

std::vector< address_txs > cryptonote::core::get_addr_tx_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 2078 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_tx_batch(combined_key, start_tx_id, batch_size, desc);
  }

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 2072 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 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 caller graph for this function:

get_balance()

uint64_t cryptonote::core::get_balance

(

const address_parse_info &

addr

)

Definition at line 2066 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 1672 of file cryptonote_core.cpp.

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

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 1589 of file cryptonote_core.cpp.

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

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 1667 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.get_block_id_by_height(height);
  }

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 1194 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 1356 of file cryptonote_core.cpp.

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

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 1361 of file cryptonote_core.cpp.

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

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 2028 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 620 of file cryptonote_core.h.

{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 627 of file cryptonote_core.h.

{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);
  }

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 1299 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.get_total_transactions();
  }

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

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

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 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 1210 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 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 1765 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 2021 of file cryptonote_core.cpp.

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

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 1760 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 1750 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 1755 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.

{return m_miner;}

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.

{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 807 of file cryptonote_core.h.

{ return m_nettype; };

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 1381 of file cryptonote_core.cpp.

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

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 1376 of file cryptonote_core.cpp.

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

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 1652 of file cryptonote_core.cpp.

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

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 1632 of file cryptonote_core.cpp.

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

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 1620 of file cryptonote_core.cpp.

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

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 1626 of file cryptonote_core.cpp.

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

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 1614 of file cryptonote_core.cpp.

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

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 1647 of file cryptonote_core.cpp.

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

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 1594 of file cryptonote_core.cpp.

  {
    return m_mempool.get_transactions_count();
  }

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.

{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 1657 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.get_short_chain_history(ids);
  }

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

get_start_time()

std::time_t cryptonote::core::get_start_time

(

)

const

gets start_time

Definition at line 2038 of file cryptonote_core.cpp.

  {
    return start_time;
  }

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 1052 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 1579 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.get_tail_id();
  }

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 2016 of file cryptonote_core.cpp.

  {
    return m_target_blockchain_height;
  }

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 805 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 810 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 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);
  }

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 1391 of file cryptonote_core.cpp.

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

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 1386 of file cryptonote_core.cpp.

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

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

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 2084 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 1419 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 1662 of file cryptonote_core.cpp.

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

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 1517 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 1042 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 944 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 1599 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.have_block(id);
  }

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 addr_db_salvage = command_line::get_arg(vm, cryptonote::arg_addr_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;
 
      if(addr_db_salvage)
        db_flags |= DBF_ADDR_TX_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 1169 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.have_tx_keyimg_as_spent(key_image);
  }

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 817 of file cryptonote_core.h.

{ return m_update_available; }

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 845 of file cryptonote_core.h.

{ return m_offline; }

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 1688 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 1477 of file cryptonote_core.cpp.

  {
    m_miner.on_synchronized();
  }

on_transaction_relayed()

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

virtual

called when a transaction is relayed

Definition at line 1342 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 831 of file cryptonote_core.h.

{ return m_pad_transactions; }

pause_mine()

void cryptonote::core::pause_mine

(

)

Note

see miner::pause

Definition at line 1396 of file cryptonote_core.cpp.

  {
    m_miner.pause();
  }

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 1637 of file cryptonote_core.cpp.

  {
    return m_mempool.have_tx(id);
  }

pool_has_utxo_as_spent()

bool cryptonote::core::pool_has_utxo_as_spent

(

const txin_to_key_public &

in

)

const

get a summary statistics of all transaction hashes in the pool

Parameters

in	input to check the pool spent status of

Note

see tx_memory_pool::utxo_spent_in_pool

Definition at line 1642 of file cryptonote_core.cpp.

  {
      return m_mempool.utxo_spent_in_pool(in);
  }

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 1493 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 1677 of file cryptonote_core.cpp.

  {
    return m_mempool.print_pool(short_format);
  }

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 2033 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 1401 of file cryptonote_core.cpp.

  {
    m_miner.resume();
  }

safesyncmode()

void cryptonote::core::safesyncmode

(

const bool

onoff

)

Put DB in safe sync mode.

2note see Blockchain::safesyncmode

Definition at line 1482 of file cryptonote_core.cpp.

  {
    m_blockchain_storage.safesyncmode(onoff);
  }

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 1584 of file cryptonote_core.cpp.

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

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

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

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 776 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.reset_and_set_genesis_block(b);
  }

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 2011 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 2043 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;
  }

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 2061 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 795 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 800 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 2001 of file cryptonote_core.cpp.

  {
    return m_blockchain_storage.update_blockchain_pruning();
  }

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:

utxo_nonexistant()

bool cryptonote::core::utxo_nonexistant	(	const std::vector< txin_to_key_public > &	public_outputs,
		std::vector< bool > &	spent ) const

check if multiple public outputs are found in the utxo database or not

plural version of is_public_output_spent()

Parameters

key_im	list of public outputs to check
spent	return-by-reference result for each public output checked

Returns

true

Definition at line 1184 of file cryptonote_core.cpp.

  {
      spent.clear();
      for(auto& po: public_outputs)
      {
          spent.push_back(m_blockchain_storage.utxo_nonexistence_from_output(po));
      }
      return true;
  }

---

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

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_core/cryptonote_core.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_core/cryptonote_core.cpp