Holds cryptonote related classes and helpers. More...

Namespaces
	bootstrap

	json

	rpc

Classes
struct	output_data_t
	a struct containing output metadata More...

struct	tx_data_t

struct	txpool_tx_meta_t
	a struct containing txpool per transaction metadata More...

struct	chainstate_key_t

struct	chainstate_value_t

struct	tx_input_t

class	DB_EXCEPTION
	A base class for BlockchainDB exceptions. More...

class	DB_ERROR
	A generic BlockchainDB exception. More...

class	DB_ERROR_TXN_START
	thrown when there is an error starting a DB transaction More...

class	DB_OPEN_FAILURE
	thrown when opening the BlockchainDB fails More...

class	DB_CREATE_FAILURE
	thrown when creating the BlockchainDB fails More...

class	DB_SYNC_FAILURE
	thrown when synchronizing the BlockchainDB to disk fails More...

class	BLOCK_DNE
	thrown when a requested block does not exist More...

class	BLOCK_PARENT_DNE
	thrown when a block's parent does not exist (and it needed to) More...

class	BLOCK_EXISTS
	thrown when a block exists, but shouldn't, namely when adding a block More...

class	BLOCK_INVALID
	thrown when something is wrong with the block to be added More...

class	TX_DNE
	thrown when a requested transaction does not exist More...

class	TX_EXISTS
	thrown when a transaction exists, but shouldn't, namely when adding a block More...

class	OUTPUT_DNE
	thrown when a requested output does not exist More...

class	OUTPUT_EXISTS
	thrown when an output exists, but shouldn't, namely when adding a block More...

class	KEY_IMAGE_EXISTS
	thrown when a spent key image exists, but shouldn't, namely when adding a block More...

class	UTXO_EXISTS
	thrown when a utxo already exists, but shouldn't, namely when adding a block More...

class	ADDR_OUTPUT_EXISTS
	thrown when an output record for an address already exists, but shouldn't, namely when adding a block More...

class	BlockchainDB
	The BlockchainDB backing store interface declaration/contract. More...

class	db_txn_guard

class	db_rtxn_guard

class	db_wtxn_guard

struct	mdb_block_info_1

struct	mdb_block_info_2

struct	mdb_block_info_3

struct	mdb_block_info_4

struct	blk_height

struct	pre_rct_outkey

struct	outkey

struct	outtx

struct	acc_outs_t

struct	txindex

struct	mdb_txn_cursors

struct	mdb_rflags

struct	mdb_threadinfo

struct	mdb_txn_safe

class	BlockchainLMDB

struct	t_hashline
	struct for loading a checkpoint from json More...

struct	t_hash_json
	struct for loading many checkpoints from json More...

class	checkpoints
	A container for blockchain checkpoints. More...

struct	account_keys

class	account_base

struct	cryptonote_connection_context

struct	address_outputs

struct	account_public_address

struct	txout_to_script

struct	txout_to_scripthash

struct	txout_to_key

struct	txout_to_key_public

struct	txin_gen

struct	txin_to_script

struct	txin_to_scripthash

struct	txin_to_key

struct	txin_to_key_public

struct	tx_out

struct	validator_db

class	transaction_prefix

class	transaction

struct	block_header

struct	block

struct	keypair

struct	integrated_address

struct	array_hasher

struct	public_address_outer_blob

struct	public_integrated_address_outer_blob

struct	address_parse_info

struct	subaddress_receive_info

struct	core_stat_info_t

class	HardFork

struct	i_miner_handler

class	miner

struct	subaddress_index

struct	tx_extra_padding

struct	tx_extra_pub_key

struct	tx_extra_nonce

struct	tx_extra_merge_mining_tag

struct	tx_extra_additional_pub_keys

struct	tx_extra_mysterious_minergate

struct	tx_verification_context

struct	block_verification_context

struct	config_t

class	Blockchain

struct	test_options

class	core
	handles core cryptonote functionality More...

struct	tx_source_entry

struct	tx_destination_entry

class	txCompare

class	tx_memory_pool
	Transaction pool, handles transactions which are not part of a block. More...

class	block_queue

struct	connection_info

struct	block_complete_entry

struct	NOTIFY_NEW_BLOCK

struct	NOTIFY_NEW_TRANSACTIONS

struct	NOTIFY_REQUEST_GET_OBJECTS

struct	NOTIFY_RESPONSE_GET_OBJECTS

struct	CORE_SYNC_DATA

struct	NOTIFY_REQUEST_CHAIN

struct	NOTIFY_RESPONSE_CHAIN_ENTRY

struct	NOTIFY_NEW_FLUFFY_BLOCK

struct	NOTIFY_REQUEST_FLUFFY_MISSING_TX

struct	NOTIFY_REQUEST_VALIDATORS_LIST

struct	NOTIFY_EMERGENCY_VALIDATORS_LIST

class	cryptonote_protocol_handler_base_pimpl

class	cryptonote_protocol_handler_base

class	t_cryptonote_protocol_handler

struct	i_cryptonote_protocol

struct	cryptonote_protocol_stub

class	pruned_transaction

class	core_rpc_server

struct	COMMAND_RPC_GET_HEIGHT

struct	COMMAND_RPC_GET_BLOCKS_FAST

struct	COMMAND_RPC_GET_BLOCKS_BY_HEIGHT

struct	COMMAND_RPC_GET_ALT_BLOCKS_HASHES

struct	COMMAND_RPC_GET_HASHES_FAST

struct	COMMAND_RPC_GET_RANDOM_OUTS

struct	COMMAND_RPC_SUBMIT_RAW_TX

struct	COMMAND_RPC_GET_TRANSACTIONS

struct	COMMAND_RPC_IS_KEY_IMAGE_SPENT

struct	COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES

struct	get_outputs_out

struct	COMMAND_RPC_GET_OUTPUTS_BIN

struct	COMMAND_RPC_GET_OUTPUTS

struct	COMMAND_RPC_SEND_RAW_TX

struct	COMMAND_RPC_START_MINING

struct	COMMAND_RPC_GET_INFO

struct	COMMAND_RPC_GET_NET_STATS

struct	COMMAND_RPC_STOP_MINING

struct	COMMAND_RPC_MINING_STATUS

struct	COMMAND_RPC_SAVE_BC

struct	COMMAND_RPC_GETBLOCKCOUNT

struct	COMMAND_RPC_GETBLOCKHASH

struct	COMMAND_RPC_GETBLOCKTEMPLATE

struct	COMMAND_RPC_SUBMITBLOCK

struct	COMMAND_RPC_GENERATEBLOCKS

struct	block_header_response

struct	COMMAND_RPC_GET_LAST_BLOCK_HEADER

struct	COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH

struct	COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT

struct	COMMAND_RPC_GET_BLOCK

struct	peer

struct	COMMAND_RPC_GET_PEER_LIST

struct	COMMAND_RPC_SET_LOG_HASH_RATE

struct	COMMAND_RPC_SET_LOG_LEVEL

struct	COMMAND_RPC_SET_LOG_CATEGORIES

struct	tx_info

struct	spent_key_image_info

struct	COMMAND_RPC_GET_TRANSACTION_POOL

struct	COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN

struct	COMMAND_RPC_GET_TRANSACTION_POOL_HASHES

struct	tx_backlog_entry

struct	COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG

struct	txpool_histo

struct	txpool_stats

struct	COMMAND_RPC_GET_TRANSACTION_POOL_STATS

struct	COMMAND_RPC_GET_BALANCE

struct	COMMAND_RPC_GET_ADDRESS_BATCH_HISTORY

struct	COMMAND_RPC_GET_CONNECTIONS

struct	COMMAND_RPC_GET_BLOCK_HEADERS_RANGE

struct	COMMAND_RPC_STOP_DAEMON

struct	COMMAND_RPC_FAST_EXIT

struct	COMMAND_RPC_GET_LIMIT

struct	COMMAND_RPC_SET_LIMIT

struct	COMMAND_RPC_OUT_PEERS

struct	COMMAND_RPC_IN_PEERS

struct	COMMAND_RPC_START_SAVE_GRAPH

struct	COMMAND_RPC_STOP_SAVE_GRAPH

struct	COMMAND_RPC_HARD_FORK_INFO

struct	COMMAND_RPC_GETBANS

struct	COMMAND_RPC_SETBANS

struct	COMMAND_RPC_FLUSH_TRANSACTION_POOL

struct	COMMAND_RPC_GET_OUTPUT_HISTOGRAM

struct	COMMAND_RPC_GET_VERSION

struct	COMMAND_RPC_GET_COINBASE_TX_SUM

struct	COMMAND_RPC_GET_BASE_FEE_ESTIMATE

struct	COMMAND_RPC_GET_ALTERNATE_CHAINS

struct	COMMAND_RPC_UPDATE

struct	COMMAND_RPC_RELAY_TX

struct	COMMAND_RPC_SYNC_INFO

struct	COMMAND_RPC_GET_OUTPUT_DISTRIBUTION

struct	COMMAND_RPC_POP_BLOCKS

struct	COMMAND_RPC_PRUNE_BLOCKCHAIN

struct	COMMAND_RPC_SET_VALIDATOR_KEY

struct	COMMAND_RPC_GENERATE_ED25519_KEYPAIR

struct	COMMAND_RPC_SIGN_MESSAGE

struct	COMMAND_RPC_INJECT_EMERGENCY_VLIST

struct	rpc_args
	Processes command line arguments related to server-side RPC. More...

class	simple_wallet
	Manages wallet operations. This is the most abstracted wallet class. More...

Typedefs
typedef std::pair< crypto::hash, uint64_t >	tx_out_index

typedef struct cryptonote::mdb_block_info_1	mdb_block_info_1

typedef struct cryptonote::mdb_block_info_2	mdb_block_info_2

typedef struct cryptonote::mdb_block_info_3	mdb_block_info_3

typedef struct cryptonote::mdb_block_info_4	mdb_block_info_4

typedef mdb_block_info_4	mdb_block_info

typedef struct cryptonote::blk_height	blk_height

typedef struct cryptonote::pre_rct_outkey	pre_rct_outkey

typedef struct cryptonote::outkey	outkey

typedef struct cryptonote::outtx	outtx

typedef struct cryptonote::acc_outs_t	acc_outs_t

typedef struct cryptonote::txindex	txindex

typedef struct cryptonote::mdb_txn_cursors	mdb_txn_cursors

typedef struct cryptonote::mdb_rflags	mdb_rflags

typedef struct cryptonote::mdb_threadinfo	mdb_threadinfo

typedef std::string	blobdata

typedef epee::span< const char >	blobdata_ref

typedef std::vector< crypto::signature >	ring_signature

typedef boost::variant< txin_gen, txin_to_script, txin_to_scripthash, txin_to_key, txin_to_key_public >	txin_v

typedef boost::variant< txout_to_script, txout_to_scripthash, txout_to_key, txout_to_key_public >	txout_target_v

typedef epee::misc_utils::struct_init< core_stat_info_t >	core_stat_info

typedef boost::multiprecision::uint128_t	difficulty_type

typedef boost::variant< tx_extra_padding, tx_extra_pub_key, tx_extra_nonce, tx_extra_merge_mining_tag, tx_extra_additional_pub_keys, tx_extra_mysterious_minergate >	tx_extra_field

typedef std::function< const epee::span< const unsigned char >cryptonote::network_type network)>	GetCheckpointsCallback
	Callback routine that returns checkpoints data for specific network type. More...

typedef std::pair< std::pair< double, std::time_t >, crypto::hash >	tx_by_fee_and_receive_time_entry
	pair of <transaction fee, transaction hash> for organization More...

typedef std::set< tx_by_fee_and_receive_time_entry, txCompare >	sorted_tx_container
	container for sorting transactions by fee per unit size More...

Enumerations
enum	{ prune_mode_prune , prune_mode_update , prune_mode_check }

enum	network_type : uint8_t { MAINNET = 0 , TESTNET , STAGENET , FAKECHAIN , UNDEFINED = 255 }

enum	blockchain_db_sync_mode { db_defaultsync , db_sync , db_async , db_nosync }

Functions
size_t	slow_memmem (const void start_buff, size_t buflen, const void pat, size_t patlen)

bool	blockchain_valid_db_type (const std::string &db_type)

std::string	blockchain_db_types (const std::string &sep)

BlockchainDB *	new_db (const std::string &db_type)

void	lmdb_resized (MDB_env *env)

int	lmdb_txn_begin (MDB_env env, MDB_txn parent, unsigned int flags, MDB_txn **txn)

int	lmdb_txn_renew (MDB_txn *txn)

std::string	get_protocol_state_string (cryptonote_connection_context::state s)

char	get_protocol_state_char (cryptonote_connection_context::state s)

template<>
unsigned int	getpos (binary_archive< true > &ar)

template<>
unsigned int	getpos (binary_archive< false > &ar)

size_t	get_min_block_weight (uint8_t version)

size_t	get_max_tx_size ()

bool	get_block_reward (size_t median_weight, size_t current_block_weight, uint64_t already_generated_coins, uint64_t &reward, uint8_t version, uint64_t current_block_height, network_type nettype)

uint8_t	get_account_address_checksum (const public_address_outer_blob &bl)

uint8_t	get_account_integrated_address_checksum (const public_integrated_address_outer_blob &bl)

std::string	get_account_address_as_str (network_type nettype, bool subaddress, account_public_address const &adr)

std::string	get_account_integrated_address_as_str (network_type nettype, account_public_address const &adr, crypto::hash8 const &payment_id)

bool	is_coinbase (const transaction &tx)

bool	get_account_address_from_str (address_parse_info &info, network_type nettype, std::string const &str)

bool	get_account_address_from_str_or_url (address_parse_info &info, network_type nettype, const std::string &str_or_url, std::function< std::string(const std::string &, const std::vector< std::string > &, bool)> dns_confirm)

bool	operator== (const cryptonote::transaction &a, const cryptonote::transaction &b)

bool	operator== (const cryptonote::block &a, const cryptonote::block &b)

void	get_transaction_prefix_hash (const transaction_prefix &tx, crypto::hash &h)

crypto::hash	get_transaction_prefix_hash (const transaction_prefix &tx)

bool	expand_transaction_1 (transaction &tx, bool base_only)

bool	parse_and_validate_tx_from_blob (const blobdata &tx_blob, transaction &tx)

bool	parse_and_validate_tx_base_from_blob (const blobdata &tx_blob, transaction &tx)

bool	parse_and_validate_tx_prefix_from_blob (const blobdata &tx_blob, transaction_prefix &tx)

bool	parse_and_validate_tx_from_blob (const blobdata &tx_blob, transaction &tx, crypto::hash &tx_hash)

bool	parse_and_validate_tx_from_blob (const blobdata &tx_blob, transaction &tx, crypto::hash &tx_hash, crypto::hash &tx_prefix_hash)

bool	is_v1_tx (const blobdata_ref &tx_blob)

bool	is_v1_tx (const blobdata &tx_blob)

bool	generate_key_image_helper (const account_keys &ack, const std::unordered_map< crypto::public_key, subaddress_index > &subaddresses, const crypto::public_key &out_key, const crypto::public_key &tx_public_key, const std::vector< crypto::public_key > &additional_tx_public_keys, size_t real_output_index, keypair &in_ephemeral, crypto::key_image &ki, hw::device &hwdev, const uint32_t account_major_offset)

bool	generate_key_image_helper_precomp (const account_keys &ack, const crypto::public_key &out_key, const crypto::key_derivation &recv_derivation, size_t real_output_index, const subaddress_index &received_index, keypair &in_ephemeral, crypto::key_image &ki, hw::device &hwdev, const uint32_t account_major_offset)

uint64_t	power_integral (uint64_t a, uint64_t b)

bool	parse_amount (uint64_t &amount, const std::string &str_amount_)

uint64_t	get_transaction_weight (const transaction &tx, size_t blob_size)

uint64_t	get_transaction_weight (const transaction &tx)

bool	get_tx_fee (const transaction &tx, uint64_t &fee)

uint64_t	get_tx_fee (const transaction &tx)

bool	parse_tx_extra (const std::vector< uint8_t > &tx_extra, std::vector< tx_extra_field > &tx_extra_fields)

bool	sort_tx_extra (const std::vector< uint8_t > &tx_extra, std::vector< uint8_t > &sorted_tx_extra, bool allow_partial)

crypto::public_key	get_tx_pub_key_from_extra (const std::vector< uint8_t > &tx_extra, size_t pk_index)

crypto::public_key	get_tx_pub_key_from_extra (const transaction_prefix &tx_prefix, size_t pk_index)

crypto::public_key	get_tx_pub_key_from_extra (const transaction &tx, size_t pk_index)

bool	add_tx_pub_key_to_extra (transaction &tx, const crypto::public_key &tx_pub_key)

bool	add_tx_pub_key_to_extra (transaction_prefix &tx, const crypto::public_key &tx_pub_key)

bool	add_tx_pub_key_to_extra (std::vector< uint8_t > &tx_extra, const crypto::public_key &tx_pub_key)

std::vector< crypto::public_key >	get_additional_tx_pub_keys_from_extra (const std::vector< uint8_t > &tx_extra)

std::vector< crypto::public_key >	get_additional_tx_pub_keys_from_extra (const transaction_prefix &tx)

bool	add_additional_tx_pub_keys_to_extra (std::vector< uint8_t > &tx_extra, const std::vector< crypto::public_key > &additional_pub_keys)

bool	add_extra_nonce_to_tx_extra (std::vector< uint8_t > &tx_extra, const blobdata &extra_nonce)

bool	remove_field_from_tx_extra (std::vector< uint8_t > &tx_extra, const std::type_info &type)

void	set_payment_id_to_tx_extra_nonce (blobdata &extra_nonce, const crypto::hash &payment_id)

void	set_encrypted_payment_id_to_tx_extra_nonce (blobdata &extra_nonce, const crypto::hash8 &payment_id)

bool	get_payment_id_from_tx_extra_nonce (const blobdata &extra_nonce, crypto::hash &payment_id)

bool	get_encrypted_payment_id_from_tx_extra_nonce (const blobdata &extra_nonce, crypto::hash8 &payment_id)

bool	get_inputs_etn_amount (const transaction &tx, uint64_t &etn)

uint64_t	get_block_height (const block &b)

bool	check_inputs_types_supported (const transaction &tx)

bool	check_outs_valid (const transaction &tx)

bool	check_etn_overflow (const transaction &tx)

bool	check_inputs_overflow (const transaction &tx)

bool	check_outs_overflow (const transaction &tx)

uint64_t	get_outs_etn_amount (const transaction &tx)

std::string	short_hash_str (const crypto::hash &h)

bool	is_out_to_acc (const account_keys &acc, const txout_to_key &out_key, const crypto::public_key &tx_pub_key, const std::vector< crypto::public_key > &additional_tx_pub_keys, size_t output_index)

boost::optional< subaddress_receive_info >	is_out_to_acc_precomp (const std::unordered_map< crypto::public_key, subaddress_index > &subaddresses, const crypto::public_key &out_key, const crypto::key_derivation &derivation, const std::vector< crypto::key_derivation > &additional_derivations, size_t output_index, hw::device &hwdev)

boost::optional< subaddress_receive_info >	is_out_to_acc_precomp_public (const std::unordered_map< crypto::public_key, subaddress_index > &subaddresses, const cryptonote::account_public_address output_address)

bool	lookup_acc_outs (const account_keys &acc, const transaction &tx, std::vector< size_t > &outs, uint64_t &etn_transfered)

bool	lookup_acc_outs (const account_keys &acc, const transaction &tx, const crypto::public_key &tx_pub_key, const std::vector< crypto::public_key > &additional_tx_pub_keys, std::vector< size_t > &outs, uint64_t &etn_transfered)

void	get_blob_hash (const epee::span< const char > &blob, crypto::hash &res)

void	get_blob_hash (const blobdata &blob, crypto::hash &res)

void	set_default_decimal_point (unsigned int decimal_point)

unsigned int	get_default_decimal_point ()

std::string	get_unit (unsigned int decimal_point)

std::string	print_etn (uint64_t amount, unsigned int decimal_point)

crypto::hash	get_blob_hash (const blobdata &blob)

crypto::hash	get_blob_hash (const epee::span< const char > &blob)

crypto::hash	get_transaction_hash (const transaction &t)

bool	get_transaction_hash (const transaction &t, crypto::hash &res)

bool	calculate_transaction_prunable_hash (const transaction &t, const cryptonote::blobdata *blob, crypto::hash &res)

crypto::hash	get_transaction_prunable_hash (const transaction &t, const cryptonote::blobdata *blobdata)

crypto::hash	get_pruned_transaction_hash (const transaction &t, const crypto::hash &pruned_data_hash)

bool	calculate_transaction_hash (const transaction &t, crypto::hash &res, size_t *blob_size)

bool	get_transaction_hash (const transaction &t, crypto::hash &res, size_t *blob_size)

bool	get_transaction_hash (const transaction &t, crypto::hash &res, size_t &blob_size)

blobdata	get_block_hashing_blob (const block &b)

bool	calculate_block_hash (const block &b, crypto::hash &res, const blobdata *blob)

bool	get_block_hash (const block &b, crypto::hash &res)

crypto::hash	get_block_hash (const block &b)

bool	get_block_longhash (const block &b, crypto::hash &res, uint64_t height)

std::vector< uint64_t >	relative_output_offsets_to_absolute (const std::vector< uint64_t > &off)

std::vector< uint64_t >	absolute_output_offsets_to_relative (const std::vector< uint64_t > &off)

crypto::hash	get_block_longhash (const block &b, uint64_t height)

bool	parse_and_validate_block_from_blob (const blobdata &b_blob, block &b, crypto::hash *block_hash)

bool	parse_and_validate_block_from_blob (const blobdata &b_blob, block &b)

bool	parse_and_validate_block_from_blob (const blobdata &b_blob, block &b, crypto::hash &block_hash)

blobdata	block_to_blob (const block &b)

bool	block_to_blob (const block &b, blobdata &b_blob)

blobdata	tx_to_blob (const transaction &tx)

bool	tx_to_blob (const transaction &tx, blobdata &b_blob)

void	get_tx_tree_hash (const std::vector< crypto::hash > &tx_hashes, crypto::hash &h)

crypto::hash	get_tx_tree_hash (const std::vector< crypto::hash > &tx_hashes)

crypto::hash	get_tx_tree_hash (const block &b)

bool	is_valid_decomposed_amount (uint64_t amount)

void	get_hash_stats (uint64_t &tx_hashes_calculated, uint64_t &tx_hashes_cached, uint64_t &block_hashes_calculated, uint64_t &block_hashes_cached)

crypto::secret_key	encrypt_key (crypto::secret_key key, const epee::wipeable_string &passphrase)

crypto::secret_key	decrypt_key (crypto::secret_key key, const epee::wipeable_string &passphrase)

template<typename T >
bool	find_tx_extra_field_by_type (const std::vector< tx_extra_field > &tx_extra_fields, T &field, size_t index=0)

template<class t_object >
bool	t_serializable_object_from_blob (t_object &to, const blobdata &b_blob)

template<class t_object >
bool	t_serializable_object_to_blob (const t_object &to, blobdata &b_blob)

template<class t_object >
blobdata	t_serializable_object_to_blob (const t_object &to)

template<class t_object >
bool	get_object_hash (const t_object &o, crypto::hash &res)

template<class t_object >
size_t	get_object_blobsize (const t_object &o)

template<class t_object >
bool	get_object_hash (const t_object &o, crypto::hash &res, size_t &blob_size)

template<typename T >
std::string	obj_to_json_str (T &obj)

template<typename chunk_handler_t , typename dust_handler_t >
void	decompose_amount_into_digits (uint64_t amount, uint64_t dust_threshold, const chunk_handler_t &chunk_handler, const dust_handler_t &dust_handler)

bool	check_hash_64 (const crypto::hash &hash, uint64_t difficulty)
	checks if a hash fits the given difficulty More...

uint64_t	next_difficulty_64 (std::vector< std::uint64_t > timestamps, std::vector< uint64_t > cumulative_difficulties, size_t target_seconds, uint8_t version)

const difficulty_type	max64bit (std::numeric_limits< std::uint64_t >::max())

const boost::multiprecision::uint256_t	max128bit (std::numeric_limits< boost::multiprecision::uint128_t >::max())

const boost::multiprecision::uint512_t	max256bit (std::numeric_limits< boost::multiprecision::uint256_t >::max())

bool	check_hash_128 (const crypto::hash &hash, difficulty_type difficulty)

bool	check_hash (const crypto::hash &hash, difficulty_type difficulty)

difficulty_type	next_difficulty (std::vector< uint64_t > timestamps, std::vector< difficulty_type > cumulative_difficulties, size_t target_seconds, uint8_t version)

std::string	hex (difficulty_type v)

difficulty_type	next_difficulty (std::vector< std::uint64_t > timestamps, std::vector< difficulty_type > cumulative_difficulties, size_t target_seconds, uint8_t version=1)

std::ostream &	operator<< (std::ostream &out, const cryptonote::subaddress_index &subaddr_index)

const config_t &	get_config (network_type nettype)

block_complete_entry	get_block_complete_entry (block &b, tx_memory_pool &pool)

double	factorial (unsigned int n)

void	classify_addresses (const std::vector< tx_destination_entry > &destinations, const boost::optional< cryptonote::account_public_address > &change_addr, size_t &num_stdaddresses, size_t &num_subaddresses, account_public_address &single_dest_subaddress)

bool	construct_miner_tx (size_t height, size_t median_weight, uint64_t already_generated_coins, size_t current_block_weight, uint64_t fee, const account_public_address &miner_address, transaction &tx, const blobdata &extra_nonce, size_t max_outs, uint8_t hard_fork_version, network_type nettype)

crypto::public_key	get_destination_view_key_pub (const std::vector< tx_destination_entry > &destinations, const boost::optional< cryptonote::account_public_address > &change_addr)

bool	construct_tx_with_tx_key (const account_keys &sender_account_keys, const std::unordered_map< crypto::public_key, subaddress_index > &subaddresses, std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations, const boost::optional< cryptonote::account_public_address > &change_addr, const std::vector< uint8_t > &extra, transaction &tx, uint64_t unlock_time, const crypto::secret_key &tx_key, const std::vector< crypto::secret_key > &additional_tx_keys, bool rct, const rct::RCTConfig &rct_config, rct::multisig_out *msout, bool shuffle_outs, const uint32_t account_major_offset, const cryptonote::network_type nettype)

bool	construct_tx_and_get_tx_key (const account_keys &sender_account_keys, const std::unordered_map< crypto::public_key, subaddress_index > &subaddresses, std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations, const boost::optional< cryptonote::account_public_address > &change_addr, const std::vector< uint8_t > &extra, transaction &tx, uint64_t unlock_time, crypto::secret_key &tx_key, std::vector< crypto::secret_key > &additional_tx_keys, bool rct, const rct::RCTConfig &rct_config, rct::multisig_out *msout, const uint32_t account_major_offset, const cryptonote::network_type nettype)

bool	construct_tx (const account_keys &sender_account_keys, std::vector< tx_source_entry > &sources, const std::vector< tx_destination_entry > &destinations, const boost::optional< cryptonote::account_public_address > &change_addr, const std::vector< uint8_t > &extra, transaction &tx, uint64_t unlock_time)

bool	generate_genesis_block (block &bl, std::string const &genesis_tx, uint32_t nonce)

bool	generate_output_ephemeral_keys (const size_t tx_version, const cryptonote::account_keys &sender_account_keys, const crypto::public_key &txkey_pub, const crypto::secret_key &tx_key, const cryptonote::tx_destination_entry &dst_entr, const boost::optional< cryptonote::account_public_address > &change_addr, const size_t output_index, const bool &need_additional_txkeys, const std::vector< crypto::secret_key > &additional_tx_keys, std::vector< crypto::public_key > &additional_tx_public_keys, std::vector< rct::key > &amount_keys, crypto::public_key &out_eph_public_key)

bool	tx_sanity_check (Blockchain &blockchain, const cryptonote::blobdata &tx_blob)

crypto::secret_key	get_multisig_blinded_secret_key (const crypto::secret_key &key)

void	generate_multisig_N_N (const account_keys &keys, const std::vector< crypto::public_key > &spend_keys, std::vector< crypto::secret_key > &multisig_keys, rct::key &spend_skey, rct::key &spend_pkey)

void	generate_multisig_N1_N (const account_keys &keys, const std::vector< crypto::public_key > &spend_keys, std::vector< crypto::secret_key > &multisig_keys, rct::key &spend_skey, rct::key &spend_pkey)

std::vector< crypto::public_key >	generate_multisig_derivations (const account_keys &keys, const std::vector< crypto::public_key > &derivations)
	generate_multisig_derivations performs common DH key derivation. Each middle round in M/N scheme is DH exchange of public multisig keys of other participants multiplied by secret spend key of current participant. this functions does the following: new multisig key = secret spend * public multisig key More...

crypto::secret_key	calculate_multisig_signer_key (const std::vector< crypto::secret_key > &multisig_keys)

std::vector< crypto::secret_key >	calculate_multisig_keys (const std::vector< crypto::public_key > &derivations)
	calculate_multisig_keys. Calculates secret multisig keys from others' participants ones as follows: mi = H(Mi) More...

crypto::secret_key	generate_multisig_view_secret_key (const crypto::secret_key &skey, const std::vector< crypto::secret_key > &skeys)

crypto::public_key	generate_multisig_M_N_spend_public_key (const std::vector< crypto::public_key > &pkeys)
	generate_multisig_M_N_spend_public_key calculates multisig wallet's spend public key by summing all of public multisig keys More...

bool	generate_multisig_key_image (const account_keys &keys, size_t multisig_key_index, const crypto::public_key &out_key, crypto::key_image &ki)

void	generate_multisig_LR (const crypto::public_key pkey, const crypto::secret_key &k, crypto::public_key &L, crypto::public_key &R)

bool	generate_multisig_composite_key_image (const account_keys &keys, const std::unordered_map< crypto::public_key, subaddress_index > &subaddresses, const crypto::public_key &out_key, const crypto::public_key &tx_public_key, const std::vector< crypto::public_key > &additional_tx_public_keys, size_t real_output_index, const std::vector< crypto::key_image > &pkis, crypto::key_image &ki)

uint32_t	multisig_rounds_required (uint32_t participants, uint32_t threshold)

Variables
std::string	arg_db_type_description = "Specify database type, available: " + cryptonote::blockchain_db_types(", ")

const command_line::arg_descriptor< std::string >	arg_db_type

const command_line::arg_descriptor< std::string >	arg_db_sync_mode

const command_line::arg_descriptor< bool >	arg_db_salvage

const command_line::arg_descriptor< bool, false >	arg_testnet_on

const command_line::arg_descriptor< bool, false >	arg_stagenet_on

const command_line::arg_descriptor< bool >	arg_regtest_on

const command_line::arg_descriptor< difficulty_type >	arg_fixed_difficulty

const command_line::arg_descriptor< bool >	arg_skip_block_sig_verification

const command_line::arg_descriptor< std::string, false, true, 2 >	arg_data_dir

const command_line::arg_descriptor< bool >	arg_offline

const command_line::arg_descriptor< bool >	arg_disable_dns_checkpoints

const command_line::arg_descriptor< size_t >	arg_block_download_max_size

const command_line::arg_descriptor< bool >	arg_fallback_to_pow

const command_line::arg_descriptor< uint64_t >	arg_fallback_to_pow_checkpoint_height

const command_line::arg_descriptor< std::string >	arg_fallback_to_pow_checkpoint_hash

Detailed Description

Holds cryptonote related classes and helpers.

Typedef Documentation

◆ acc_outs_t

typedef struct cryptonote::acc_outs_t cryptonote::acc_outs_t

◆ blk_height

typedef struct cryptonote::blk_height cryptonote::blk_height

◆ blobdata

typedef std::string cryptonote::blobdata

Definition at line 39 of file blobdatatype.h.

◆ blobdata_ref

typedef epee::span<const char> cryptonote::blobdata_ref

Definition at line 40 of file blobdatatype.h.

◆ core_stat_info

typedef epee::misc_utils::struct_init<core_stat_info_t> cryptonote::core_stat_info

Definition at line 54 of file cryptonote_stat_info.h.

◆ difficulty_type

typedef boost::multiprecision::uint128_t cryptonote::difficulty_type

Definition at line 43 of file difficulty.h.

◆ GetCheckpointsCallback

typedef std::function<const epee::span<const unsigned char>cryptonote::network_type network)> cryptonote::GetCheckpointsCallback

Callback routine that returns checkpoints data for specific network type.

Parameters

network network type

Returns: checkpoints data, empty span if there ain't any checkpoints for specific network type

Definition at line 92 of file blockchain.h.

◆ mdb_block_info

typedef mdb_block_info_4 cryptonote::mdb_block_info

Definition at line 353 of file db_lmdb.cpp.

◆ mdb_block_info_1

typedef struct cryptonote::mdb_block_info_1 cryptonote::mdb_block_info_1

◆ mdb_block_info_2

typedef struct cryptonote::mdb_block_info_2 cryptonote::mdb_block_info_2

◆ mdb_block_info_3

typedef struct cryptonote::mdb_block_info_3 cryptonote::mdb_block_info_3

◆ mdb_block_info_4

typedef struct cryptonote::mdb_block_info_4 cryptonote::mdb_block_info_4

◆ mdb_rflags

typedef struct cryptonote::mdb_rflags cryptonote::mdb_rflags

◆ mdb_threadinfo

typedef struct cryptonote::mdb_threadinfo cryptonote::mdb_threadinfo

◆ mdb_txn_cursors

typedef struct cryptonote::mdb_txn_cursors cryptonote::mdb_txn_cursors

◆ outkey

typedef struct cryptonote::outkey cryptonote::outkey

◆ outtx

typedef struct cryptonote::outtx cryptonote::outtx

◆ pre_rct_outkey

typedef struct cryptonote::pre_rct_outkey cryptonote::pre_rct_outkey

◆ ring_signature

typedef std::vector<crypto::signature> cryptonote::ring_signature

Definition at line 57 of file cryptonote_basic.h.

◆ sorted_tx_container

typedef std::set<tx_by_fee_and_receive_time_entry, txCompare> cryptonote::sorted_tx_container

container for sorting transactions by fee per unit size

Definition at line 78 of file tx_pool.h.

◆ tx_by_fee_and_receive_time_entry

typedef std::pair<std::pair<double, std::time_t>, crypto::hash> cryptonote::tx_by_fee_and_receive_time_entry

pair of <transaction fee, transaction hash> for organization

Definition at line 60 of file tx_pool.h.

◆ tx_extra_field

typedef boost::variant<tx_extra_padding, tx_extra_pub_key, tx_extra_nonce, tx_extra_merge_mining_tag, tx_extra_additional_pub_keys, tx_extra_mysterious_minergate> cryptonote::tx_extra_field

Definition at line 187 of file tx_extra.h.

◆ tx_out_index

typedef std::pair<crypto::hash, uint64_t> cryptonote::tx_out_index

a pair of <transaction hash, output index>, typedef for convenience

Definition at line 106 of file blockchain_db.h.

◆ txin_v

typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_to_key, txin_to_key_public> cryptonote::txin_v

Definition at line 217 of file cryptonote_basic.h.

◆ txindex

typedef struct cryptonote::txindex cryptonote::txindex

◆ txout_target_v

typedef boost::variant<txout_to_script, txout_to_scripthash, txout_to_key, txout_to_key_public> cryptonote::txout_target_v

Definition at line 219 of file cryptonote_basic.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
prune_mode_prune
prune_mode_update
prune_mode_check

Definition at line 2441 of file db_lmdb.cpp.

2441 { prune_mode_prune, prune_mode_update, prune_mode_check };

cryptonote::prune_mode_update

@ prune_mode_update

Definition: db_lmdb.cpp:2441

cryptonote::prune_mode_check

@ prune_mode_check

Definition: db_lmdb.cpp:2441

cryptonote::prune_mode_prune

@ prune_mode_prune

Definition: db_lmdb.cpp:2441

◆ blockchain_db_sync_mode

enum cryptonote::blockchain_db_sync_mode

Declares ways in which the BlockchainDB backend should be told to sync

Enumerator
db_defaultsync	user didn't specify, use db_async
db_sync	handle syncing calls instead of the backing db, synchronously
db_async	handle syncing calls instead of the backing db, asynchronously
db_nosync	Leave syncing up to the backing db (safest, but slowest because of disk I/O)

Definition at line 77 of file blockchain.h.

   {
     db_defaultsync, 
     db_sync,  
     db_async, 
     db_nosync 
   };

◆ network_type

enum cryptonote::network_type : uint8_t

Enumerator
MAINNET
TESTNET
STAGENET
FAKECHAIN
UNDEFINED

Definition at line 244 of file cryptonote_config.h.

   {
     MAINNET = 0,
     TESTNET,
     STAGENET,
     FAKECHAIN,
     UNDEFINED = 255
   };

Function Documentation

◆ absolute_output_offsets_to_relative()

std::vector< uint64_t > cryptonote::absolute_output_offsets_to_relative ( const std::vector< uint64_t > & off )

Definition at line 1188 of file cryptonote_format_utils.cpp.

   {
     std::vector<uint64_t> res = off;
     if(!off.size())
       return res;
     std::sort(res.begin(), res.end());//just to be sure, actually it is already should be sorted
     for(size_t i = res.size()-1; i != 0; i--)
       res[i] -= res[i-1];
  
     return res;
   }

◆ add_additional_tx_pub_keys_to_extra()

bool cryptonote::add_additional_tx_pub_keys_to_extra	(	std::vector< uint8_t > &	tx_extra,
		const std::vector< crypto::public_key > &	additional_pub_keys
	)

Definition at line 572 of file cryptonote_format_utils.cpp.

   {
     // convert to variant
     tx_extra_field field = tx_extra_additional_pub_keys{ additional_pub_keys };
     // serialize
     std::ostringstream oss;
     binary_archive<true> ar(oss);
     bool r = ::do_serialize(ar, field);
     CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to serialize tx extra additional tx pub keys");
     // append
     std::string tx_extra_str = oss.str();
     size_t pos = tx_extra.size();
     tx_extra.resize(tx_extra.size() + tx_extra_str.size());
     memcpy(&tx_extra[pos], tx_extra_str.data(), tx_extra_str.size());
     return true;
   }

Here is the call graph for this function:

◆ add_extra_nonce_to_tx_extra()

bool cryptonote::add_extra_nonce_to_tx_extra	(	std::vector< uint8_t > &	tx_extra,
		const blobdata &	extra_nonce
	)

Definition at line 589 of file cryptonote_format_utils.cpp.

   {
     CHECK_AND_ASSERT_MES(extra_nonce.size() <= TX_EXTRA_NONCE_MAX_COUNT, false, "extra nonce could be 255 bytes max");
     size_t start_pos = tx_extra.size();
     tx_extra.resize(tx_extra.size() + 2 + extra_nonce.size());
     //write tag
     tx_extra[start_pos] = TX_EXTRA_NONCE;
     //write len
     ++start_pos;
     tx_extra[start_pos] = static_cast<uint8_t>(extra_nonce.size());
     //write data
     ++start_pos;
     memcpy(&tx_extra[start_pos], extra_nonce.data(), extra_nonce.size());
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_tx_pub_key_to_extra() [1/3]

bool cryptonote::add_tx_pub_key_to_extra	(	std::vector< uint8_t > &	tx_extra,
		const crypto::public_key &	tx_pub_key
	)

Definition at line 547 of file cryptonote_format_utils.cpp.

   {
     tx_extra.resize(tx_extra.size() + 1 + sizeof(crypto::public_key));
     tx_extra[tx_extra.size() - 1 - sizeof(crypto::public_key)] = TX_EXTRA_TAG_PUBKEY;
     *reinterpret_cast<crypto::public_key*>(&tx_extra[tx_extra.size() - sizeof(crypto::public_key)]) = tx_pub_key;
     return true;
   }

Here is the caller graph for this function:

◆ add_tx_pub_key_to_extra() [2/3]

bool cryptonote::add_tx_pub_key_to_extra	(	transaction &	tx,
		const crypto::public_key &	tx_pub_key
	)

Definition at line 537 of file cryptonote_format_utils.cpp.

   {
     return add_tx_pub_key_to_extra(tx.extra, tx_pub_key);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_tx_pub_key_to_extra() [3/3]

bool cryptonote::add_tx_pub_key_to_extra	(	transaction_prefix &	tx,
		const crypto::public_key &	tx_pub_key
	)

Definition at line 542 of file cryptonote_format_utils.cpp.

   {
     return add_tx_pub_key_to_extra(tx.extra, tx_pub_key);
   }

Here is the call graph for this function:

◆ block_to_blob() [1/2]

blobdata cryptonote::block_to_blob ( const block & b )

Definition at line 1236 of file cryptonote_format_utils.cpp.

   {
     return t_serializable_object_to_blob(b);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_to_blob() [2/2]

bool cryptonote::block_to_blob	(	const block &	b,
		blobdata &	b_blob
	)

Definition at line 1241 of file cryptonote_format_utils.cpp.

   {
     return t_serializable_object_to_blob(b, b_blob);
   }

Here is the call graph for this function:

◆ blockchain_db_types()

std::string cryptonote::blockchain_db_types ( const std::string & sep )

Definition at line 70 of file blockchain_db.cpp.

 {
   int i;
   std::string ret = "";
   for (i=0; db_types[i]; i++)
   {
     if (i)
       ret += sep;
     ret += db_types[i];
   }
   return ret;
 }

Here is the caller graph for this function:

◆ blockchain_valid_db_type()

bool cryptonote::blockchain_valid_db_type ( const std::string & db_type )

Definition at line 59 of file blockchain_db.cpp.

 {
   int i;
   for (i=0; db_types[i]; i++)
   {
     if (db_types[i] == db_type)
       return true;
   }
   return false;
 }

Here is the caller graph for this function:

◆ calculate_block_hash()

bool cryptonote::calculate_block_hash	(	const block &	b,
		crypto::hash &	res,
		const blobdata *	blob
	)

Definition at line 1140 of file cryptonote_format_utils.cpp.

   {
     return get_object_hash(get_block_hashing_blob(b), res);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_multisig_keys()

std::vector< crypto::secret_key > cryptonote::calculate_multisig_keys ( const std::vector< crypto::public_key > & derivations )

calculate_multisig_keys. Calculates secret multisig keys from others' participants ones as follows: mi = H(Mi)

Parameters

derivations - others' participants public multisig keys.

Returns: vector of current wallet's multisig secret keys

Definition at line 111 of file multisig.cpp.

   {
     std::vector<crypto::secret_key> multisig_keys;
     multisig_keys.reserve(derivations.size());
  
     for (const auto &k: derivations)
     {
       multisig_keys.emplace_back(get_multisig_blinded_secret_key(rct::rct2sk(rct::pk2rct(k))));
     }
  
     return multisig_keys;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_multisig_signer_key()

crypto::secret_key cryptonote::calculate_multisig_signer_key ( const std::vector< crypto::secret_key > & multisig_keys )

Definition at line 100 of file multisig.cpp.

   {
     rct::key secret_key = rct::zero();
     for (const auto &k: multisig_keys)
     {
       sc_add(secret_key.bytes, secret_key.bytes, (const unsigned char*)k.data);
     }
  
     return rct::rct2sk(secret_key);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_transaction_hash()

bool cryptonote::calculate_transaction_hash	(	const transaction &	t,
		crypto::hash &	res,
		size_t *	blob_size
	)

Definition at line 1042 of file cryptonote_format_utils.cpp.

   {
     // v1 transactions hash the entire blob
     if (t.version == 1)
     {
       size_t ignored_blob_size, &blob_size_ref = blob_size ? *blob_size : ignored_blob_size;
       return get_object_hash(t, res, blob_size_ref);
     }
  
     // v2 transactions hash different parts together, than hash the set of those hashes
     crypto::hash hashes[3];
  
     // prefix
     get_transaction_prefix_hash(t, hashes[0]);
  
     const blobdata blob = tx_to_blob(t);
     const unsigned int unprunable_size = t.unprunable_size;
     const unsigned int prefix_size = t.prefix_size;
  
     // base rct
     CHECK_AND_ASSERT_MES(prefix_size <= unprunable_size && unprunable_size <= blob.size(), false, "Inconsistent transaction prefix, unprunable and blob sizes");
     cryptonote::get_blob_hash(epee::span<const char>(blob.data() + prefix_size, unprunable_size - prefix_size), hashes[1]);
  
     // prunable rct
     if (t.rct_signatures.type == rct::RCTTypeNull)
     {
       hashes[2] = crypto::null_hash;
     }
     else
     {
       CHECK_AND_ASSERT_MES(calculate_transaction_prunable_hash(t, &blob, hashes[2]), false, "Failed to get tx prunable hash");
     }
  
     // the tx hash is the hash of the 3 hashes
     res = cn_fast_hash(hashes, sizeof(hashes));
  
     // we still need the size
     if (blob_size)
     {
       if (!t.is_blob_size_valid())
       {
         t.blob_size = blob.size();
         t.set_blob_size_valid(true);
       }
       *blob_size = t.blob_size;
     }
  
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_transaction_prunable_hash()

bool cryptonote::calculate_transaction_prunable_hash	(	const transaction &	t,
		const cryptonote::blobdata *	blob,
		crypto::hash &	res
	)

Definition at line 975 of file cryptonote_format_utils.cpp.

   {
     if (t.version == 1)
       return false;
     const unsigned int unprunable_size = t.unprunable_size;
     if (blob && unprunable_size)
     {
       CHECK_AND_ASSERT_MES(unprunable_size <= blob->size(), false, "Inconsistent transaction unprunable and blob sizes");
       cryptonote::get_blob_hash(epee::span<const char>(blob->data() + unprunable_size, blob->size() - unprunable_size), res);
     }
     else
     {
       transaction &tt = const_cast<transaction&>(t);
       std::stringstream ss;
       binary_archive<true> ba(ss);
       const size_t inputs = t.vin.size();
       const size_t outputs = t.vout.size();
       const size_t mixin = t.vin.empty() ? 0 : t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 : 0;
       bool r = tt.rct_signatures.p.serialize_rctsig_prunable(ba, t.rct_signatures.type, inputs, outputs, mixin);
       CHECK_AND_ASSERT_MES(r, false, "Failed to serialize rct signatures prunable");
       cryptonote::get_blob_hash(ss.str(), res);
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_etn_overflow()

bool cryptonote::check_etn_overflow ( const transaction & tx )

Definition at line 753 of file cryptonote_format_utils.cpp.

   {
     return check_inputs_overflow(tx) && check_outs_overflow(tx);
   }

Here is the call graph for this function:

◆ check_hash()

bool cryptonote::check_hash	(	const crypto::hash &	hash,
		difficulty_type	difficulty
	)

Definition at line 203 of file difficulty.cpp.

                                                                       {
     if (difficulty <= max64bit) // if can convert to small difficulty - do it
       return check_hash_64(hash, difficulty.convert_to<std::uint64_t>());
     else
       return check_hash_128(hash, difficulty);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_hash_128()

bool cryptonote::check_hash_128	(	const crypto::hash &	hash,
		difficulty_type	difficulty
	)

Definition at line 184 of file difficulty.cpp.

                                                                           {
 #ifndef FORCE_FULL_128_BITS
     // fast check
     if (difficulty >= max64bit && ((const uint64_t *) &hash)[3] > 0)
       return false;
 #endif
     // usual slow check
     boost::multiprecision::uint512_t hashVal = 0;
 #ifdef FORCE_FULL_128_BITS
     for(int i = 0; i < 4; i++) { // highest word is zero
 #else
     for(int i = 1; i < 4; i++) { // highest word is zero
 #endif
       hashVal <<= 64;
       hashVal |= swap64le(((const uint64_t *) &hash)[3 - i]);
     }
     return hashVal * difficulty <= max256bit;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_hash_64()

bool cryptonote::check_hash_64	(	const crypto::hash &	hash,
		uint64_t	difficulty
	)

checks if a hash fits the given difficulty

The hash passes if (hash * difficulty) < 2^256. Phrased differently, if (hash * difficulty) fits without overflow into the least significant 256 bits of the 320 bit multiplication result.

Parameters

hash	the hash to check
difficulty	the difficulty to check against

Returns: true if valid, else false

Definition at line 106 of file difficulty.cpp.

                                                                   {
     uint64_t low, high, top, cur;
     // First check the highest word, this will most likely fail for a random hash.
     mul(swap64le(((const uint64_t *) &hash)[3]), difficulty, top, high);
     if (high != 0) {
       return false;
     }
     mul(swap64le(((const uint64_t *) &hash)[0]), difficulty, low, cur);
     mul(swap64le(((const uint64_t *) &hash)[1]), difficulty, low, high);
     bool carry = cadd(cur, low);
     cur = high;
     mul(swap64le(((const uint64_t *) &hash)[2]), difficulty, low, high);
     carry = cadc(cur, low, carry);
     carry = cadc(high, top, carry);
     return !carry;
   }

Here is the caller graph for this function:

◆ check_inputs_overflow()

bool cryptonote::check_inputs_overflow ( const transaction & tx )

Definition at line 758 of file cryptonote_format_utils.cpp.

   {
     uint64_t etn = 0;
     if(tx.version >= 3)
     {
       for(const auto& in: tx.vin)
       {
         CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key_public, tokey_in, false);
         if(etn > tokey_in.amount + etn)
           return false;
         etn += tokey_in.amount;
       }
       return true;
     }
  
     for(const auto& in: tx.vin)
     {
       CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
       if(etn > tokey_in.amount + etn)
         return false;
       etn += tokey_in.amount;
     }
     return true;
   }

Here is the caller graph for this function:

◆ check_inputs_types_supported()

bool cryptonote::check_inputs_types_supported ( const transaction & tx )

Definition at line 701 of file cryptonote_format_utils.cpp.

   {
     for(const auto& in: tx.vin)
     {
       if (tx.version == 1 || tx.version == 2)
       {
         CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), false, "wrong variant type: "
                 << in.type().name() << ", expected " << typeid(txin_to_key).name()
                 << ", in transaction id=" << get_transaction_hash(tx));
       }
       else //tx.version >= 3 (public transactions: can spend only new inputs)
       {
         CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key_public), false, "wrong variant type: "
                 << in.type().name() << ", expected " << typeid(txin_to_key_public).name()
                 << ", in transaction id=" << get_transaction_hash(tx));
       }
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_outs_overflow()

bool cryptonote::check_outs_overflow ( const transaction & tx )

Definition at line 783 of file cryptonote_format_utils.cpp.

   {
     uint64_t etn = 0;
     for(const auto& o: tx.vout)
     {
       if(etn > o.amount + etn)
         return false;
       etn += o.amount;
     }
     return true;
   }

Here is the caller graph for this function:

◆ check_outs_valid()

bool cryptonote::check_outs_valid ( const transaction & tx )

Definition at line 721 of file cryptonote_format_utils.cpp.

   {
     for(const tx_out& out: tx.vout)
     {
       if (tx.version == 1)
       {
         CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key), false, "wrong variant type: "
                 << out.target.type().name() << ", expected " << typeid(txout_to_key).name()
                 << ", in transaction id=" << get_transaction_hash(tx));
  
         CHECK_AND_NO_ASSERT_MES(0 < out.amount, false, "zero amount output in transaction id=" << get_transaction_hash(tx));
  
         if(!check_key(boost::get<txout_to_key>(out.target).key))
           return false;
       }
       else //tx.version >= 2 (public transactions: only new public outputs are allowed)
       {
         CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key_public), false, "wrong variant type: "
                 << out.target.type().name() << ", expected " << typeid(txout_to_key_public).name()
                 << ", in transaction id=" << get_transaction_hash(tx));
  
         CHECK_AND_NO_ASSERT_MES(0 < out.amount, false, "zero amount output in transaction id=" << get_transaction_hash(tx));
  
         if(!check_key(boost::get<txout_to_key_public>(out.target).address.m_spend_public_key) ||
                 !check_key(boost::get<txout_to_key_public>(out.target).address.m_view_public_key))
           return false;
       }
  
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ classify_addresses()

void cryptonote::classify_addresses	(	const std::vector< tx_destination_entry > &	destinations,
		const boost::optional< cryptonote::account_public_address > &	change_addr,
		size_t &	num_stdaddresses,
		size_t &	num_subaddresses,
		account_public_address &	single_dest_subaddress
	)

Definition at line 53 of file cryptonote_tx_utils.cpp.

   {
     num_stdaddresses = 0;
     num_subaddresses = 0;
     std::unordered_set<cryptonote::account_public_address> unique_dst_addresses;
     for(const tx_destination_entry& dst_entr: destinations)
     {
       if (change_addr && dst_entr.addr == change_addr)
         continue;
       if (unique_dst_addresses.count(dst_entr.addr) == 0)
       {
         unique_dst_addresses.insert(dst_entr.addr);
         if (dst_entr.is_subaddress)
         {
           ++num_subaddresses;
           single_dest_subaddress = dst_entr.addr;
         }
         else
         {
           ++num_stdaddresses;
         }
       }
     }
     LOG_PRINT_L2("destinations include " << num_stdaddresses << " standard addresses and " << num_subaddresses << " subaddresses");
   }

Here is the caller graph for this function:

◆ construct_miner_tx()

bool cryptonote::construct_miner_tx	(	size_t	height,
		size_t	median_weight,
		uint64_t	already_generated_coins,
		size_t	current_block_weight,
		uint64_t	fee,
		const account_public_address &	miner_address,
		transaction &	tx,
		const blobdata &	extra_nonce,
		size_t	max_outs,
		uint8_t	hard_fork_version,
		network_type	nettype
	)

Definition at line 79 of file cryptonote_tx_utils.cpp.

                                                                                                                                                                                                                                                                                                          {
     tx.vin.clear();
     tx.vout.clear();
     tx.extra.clear();
  
     txin_gen in;
     in.height = height;
  
     uint64_t block_reward;
     if(!get_block_reward(median_weight, current_block_weight, already_generated_coins, block_reward, hard_fork_version, height, nettype))
     {
       LOG_PRINT_L0("Block is too big");
       return false;
     }
  
 #if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
     LOG_PRINT_L1("Creating block template: reward " << block_reward <<
       ", fee " << fee);
 #endif
     block_reward += fee;
  
     // from hard fork 2, we cut out the low significant digits. This makes the tx smaller, and
     // keeps the paid amount almost the same. The unpaid remainder gets pushed back to the
     // emission schedule
     // from hard fork 4, we use a single "dusty" output. This makes the tx even smaller,
     // and avoids the quantization. These outputs will be added as rct outputs with identity
     // masks, to they can be used as rct inputs.
     if (hard_fork_version >= 2 && hard_fork_version < 4) {
       block_reward = block_reward - block_reward % ::config::BASE_REWARD_CLAMP_THRESHOLD;
     }
  
     std::vector<uint64_t> out_amounts;
     decompose_amount_into_digits(block_reward, hard_fork_version >= 2 ? 0 : ::config::DEFAULT_DUST_THRESHOLD,
       [&out_amounts](uint64_t a_chunk) { out_amounts.push_back(a_chunk); },
       [&out_amounts](uint64_t a_dust) { out_amounts.push_back(a_dust); });
  
     CHECK_AND_ASSERT_MES(1 <= max_outs, false, "max_out must be non-zero");
     if (height == 0 || hard_fork_version >= 4)
     {
       // the genesis block was not decomposed, for unknown reasons
       while (max_outs < out_amounts.size())
       {
         //out_amounts[out_amounts.size() - 2] += out_amounts.back();
         //out_amounts.resize(out_amounts.size() - 1);
         out_amounts[1] += out_amounts[0];
         for (size_t n = 1; n < out_amounts.size(); ++n)
           out_amounts[n - 1] = out_amounts[n];
         out_amounts.pop_back();
       }
     }
     else
     {
       CHECK_AND_ASSERT_MES(max_outs >= out_amounts.size(), false, "max_out exceeded");
     }
  
     uint64_t summary_amounts = 0;
     if (hard_fork_version >= HF_VERSION_PUBLIC_TX)
     {
       for (const auto out_amount : out_amounts)
       {
         txout_to_key_public tk;
         tk.address.m_view_public_key = miner_address.m_view_public_key;
         tk.address.m_spend_public_key = miner_address.m_spend_public_key;
         tk.m_address_prefix = get_config(nettype).CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX;
  
         tx_out out;
         summary_amounts += out.amount = out_amount;
         out.target = tk;
         tx.vout.push_back(out);
       }
  
       tx.version = 3;
     }
     else
     {
       keypair txkey = keypair::generate(hw::get_device("default"));
       add_tx_pub_key_to_extra(tx, txkey.pub);
       if(!extra_nonce.empty())
         if(!add_extra_nonce_to_tx_extra(tx.extra, extra_nonce))
           return false;
       if (!sort_tx_extra(tx.extra, tx.extra))
         return false;
  
       for (size_t no = 0; no < out_amounts.size(); no++)
       {
         crypto::key_derivation derivation = AUTO_VAL_INIT(derivation);;
         crypto::public_key out_eph_public_key = AUTO_VAL_INIT(out_eph_public_key);
         bool r = crypto::generate_key_derivation(miner_address.m_view_public_key, txkey.sec, derivation);
         CHECK_AND_ASSERT_MES(r, false, "while creating outs: failed to generate_key_derivation(" << miner_address.m_view_public_key << ", " << txkey.sec << ")");
  
         r = crypto::derive_public_key(derivation, no, miner_address.m_spend_public_key, out_eph_public_key);
         CHECK_AND_ASSERT_MES(r, false, "while creating outs: failed to derive_public_key(" << derivation << ", " << no << ", "<< miner_address.m_spend_public_key << ")");
  
         txout_to_key tk;
         tk.key = out_eph_public_key;
  
         tx_out out;
         summary_amounts += out.amount = out_amounts[no];
         out.target = tk;
         tx.vout.push_back(out);
       }
  
       tx.version = 1;
     }
  
  
     CHECK_AND_ASSERT_MES(summary_amounts == block_reward, false, "Failed to construct miner tx, summary_amounts = " << summary_amounts << " not equal block_reward = " << block_reward);
  
     //lock
     tx.unlock_time = height + (hard_fork_version > 7 ? ETN_MINED_ETN_UNLOCK_WINDOW_V8 : CRYPTONOTE_MINED_ETN_UNLOCK_WINDOW);
     tx.vin.push_back(in);
  
     tx.invalidate_hashes();
  
     //LOG_PRINT("MINER_TX generated ok, block_reward=" << print_etn(block_reward) << "("  << print_etn(block_reward - fee) << "+" << print_etn(fee)
     //  << "), current_block_size=" << current_block_size << ", already_generated_coins=" << already_generated_coins << ", tx_id=" << get_transaction_hash(tx), LOG_LEVEL_2);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_tx()

bool cryptonote::construct_tx	(	const account_keys &	sender_account_keys,
		std::vector< tx_source_entry > &	sources,
		const std::vector< tx_destination_entry > &	destinations,
		const boost::optional< cryptonote::account_public_address > &	change_addr,
		const std::vector< uint8_t > &	extra,
		transaction &	tx,
		uint64_t	unlock_time
	)

Definition at line 603 of file cryptonote_tx_utils.cpp.

   {
      std::unordered_map<crypto::public_key, cryptonote::subaddress_index> subaddresses;
      subaddresses[sender_account_keys.m_account_address.m_spend_public_key] = {0,0};
      crypto::secret_key tx_key;
      std::vector<crypto::secret_key> additional_tx_keys;
      std::vector<tx_destination_entry> destinations_copy = destinations;
      return construct_tx_and_get_tx_key(sender_account_keys, subaddresses, sources, destinations_copy, change_addr, extra, tx, unlock_time, tx_key, additional_tx_keys, false, { rct::RangeProofBorromean, 0}, NULL);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_tx_and_get_tx_key()

bool cryptonote::construct_tx_and_get_tx_key	(	const account_keys &	sender_account_keys,
		const std::unordered_map< crypto::public_key, subaddress_index > &	subaddresses,
		std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations,
		const boost::optional< cryptonote::account_public_address > &	change_addr,
		const std::vector< uint8_t > &	extra,
		transaction &	tx,
		uint64_t	unlock_time,
		crypto::secret_key &	tx_key,
		std::vector< crypto::secret_key > &	additional_tx_keys,
		bool	rct,
		const rct::RCTConfig &	rct_config,
		rct::multisig_out *	msout,
		const uint32_t	account_major_offset,
		const cryptonote::network_type	nettype
	)

Definition at line 575 of file cryptonote_tx_utils.cpp.

   {
     hw::device &hwdev = sender_account_keys.get_device();
     hwdev.open_tx(tx_key);
     try {
       // figure out if we need to make additional tx pubkeys
       size_t num_stdaddresses = 0;
       size_t num_subaddresses = 0;
       account_public_address single_dest_subaddress;
       classify_addresses(destinations, change_addr, num_stdaddresses, num_subaddresses, single_dest_subaddress);
       bool need_additional_txkeys = num_subaddresses > 0 && (num_stdaddresses > 0 || num_subaddresses > 1);
       if (need_additional_txkeys)
       {
         additional_tx_keys.clear();
         for (const auto &d: destinations)
           additional_tx_keys.push_back(keypair::generate(sender_account_keys.get_device()).sec);
       }
  
       bool r = construct_tx_with_tx_key(sender_account_keys, subaddresses, sources, destinations, change_addr, extra, tx, unlock_time, tx_key, additional_tx_keys, rct, rct_config, msout, true, account_major_offset, nettype);
       hwdev.close_tx();
       return r;
     } catch(...) {
       hwdev.close_tx();
       throw;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_tx_with_tx_key()

bool cryptonote::construct_tx_with_tx_key	(	const account_keys &	sender_account_keys,
		const std::unordered_map< crypto::public_key, subaddress_index > &	subaddresses,
		std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations,
		const boost::optional< cryptonote::account_public_address > &	change_addr,
		const std::vector< uint8_t > &	extra,
		transaction &	tx,
		uint64_t	unlock_time,
		const crypto::secret_key &	tx_key,
		const std::vector< crypto::secret_key > &	additional_tx_keys,
		bool	rct,
		const rct::RCTConfig &	rct_config,
		rct::multisig_out *	msout,
		bool	shuffle_outs,
		const uint32_t	account_major_offset,
		const cryptonote::network_type	nettype
	)

Definition at line 220 of file cryptonote_tx_utils.cpp.

   {
     hw::device &hwdev = sender_account_keys.get_device();
  
     if (sources.empty())
     {
       LOG_ERROR("Empty sources");
       return false;
     }
  
     std::vector<rct::key> amount_keys;
     //test tx is sent through this scope TWICE, once as a test and once for real... therefore we set null before each run.
     tx.set_null_besides_version();
     amount_keys.clear();
     if (msout)
     {
       msout->c.clear();
     }
  
     tx.unlock_time = unlock_time;
  
     tx.extra = extra;
     crypto::public_key txkey_pub;
  
     // if we have a stealth payment id, find it and encrypt it with the tx key now
     std::vector<tx_extra_field> tx_extra_fields;
     if (parse_tx_extra(tx.extra, tx_extra_fields))
     {
       bool add_dummy_payment_id = true;
       tx_extra_nonce extra_nonce;
       if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
       {
         crypto::hash payment_id = null_hash;
         crypto::hash8 payment_id8 = null_hash8;
         if (get_encrypted_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id8))
         {
           LOG_PRINT_L2("Adding cleartext payment ID to extra nonce. Encrypted PIDs are now deprecated." << payment_id8);
  
           std::string extra_nonce;
  
           memcpy(payment_id.data, payment_id8.data, 8); // convert short pid to regular
           memset(payment_id.data + 8, 0, 24); // merely a sanity check
  
           set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
           remove_field_from_tx_extra(tx.extra, typeid(tx_extra_nonce));
           if (!add_extra_nonce_to_tx_extra(tx.extra, extra_nonce))
           {
             LOG_ERROR("Failed to add payment id to tx extra");
             return false;
           }
           LOG_PRINT_L1("Encrypted payment ID: " << payment_id8);
           add_dummy_payment_id = false;
         }
         else if (get_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id))
         {
           add_dummy_payment_id = false;
         }
       }
  
       // we don't add one if we've got more than the usual 1 destination plus change
       if (destinations.size() > 2)
         add_dummy_payment_id = false;
  
       if (add_dummy_payment_id)
       {
         std::string extra_nonce;
         crypto::hash payment_id = null_hash;
  
         set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
         if (!add_extra_nonce_to_tx_extra(tx.extra, extra_nonce))
         {
           LOG_ERROR("Failed to add dummy payment id to tx extra");
           // continue anyway
         }
       }
     }
     else
     {
       MWARNING("Failed to parse tx extra");
       tx_extra_fields.clear();
     }
  
     struct input_generation_context_data
     {
       keypair in_ephemeral;
     };
     std::vector<input_generation_context_data> in_contexts;
  
     uint64_t summary_inputs_etn = 0;
     //fill inputs
     int idx = -1;
  
     if(tx.version < 3) {
         for (const tx_source_entry &src_entr : sources) {
             ++idx;
             if (src_entr.real_output >= src_entr.outputs.size()) {//
                 LOG_ERROR("real_output index (" << src_entr.real_output << ")bigger than output_keys.size()="
                                                 << src_entr.outputs.size());
                 return false;
             }
             summary_inputs_etn += src_entr.amount;
  
             //key_derivation recv_derivation;
             in_contexts.push_back(input_generation_context_data());
             // Tx output private key which gets its value assigned inside generate_key_image_helper
             keypair &in_ephemeral = in_contexts.back().in_ephemeral;
             crypto::key_image img;//
             const auto &out_key = reinterpret_cast<const crypto::public_key &>(src_entr.outputs[src_entr.real_output].second.dest);
             if (!generate_key_image_helper(sender_account_keys, subaddresses, out_key, src_entr.real_out_tx_key,
                                            src_entr.real_out_additional_tx_keys, src_entr.real_output_in_tx_index,
                                            in_ephemeral, img, hwdev, account_major_offset)) {
                 LOG_ERROR("Key image generation failed!");
                 return false;
             }
  
             //check that derivated key is equal with real output key (if non multisig)
             if (!msout && !(in_ephemeral.pub == src_entr.outputs[src_entr.real_output].second.dest)) {
                 LOG_ERROR("derived public key mismatch with output public key at index "
                             << idx << ", real out "
                             << src_entr.real_output << "! "
                             << ENDL << "derived_key:"
                             << string_tools::pod_to_hex(in_ephemeral.pub)
                             << ENDL
                             << "real output_public_key:"
                             << string_tools::pod_to_hex(src_entr.outputs[src_entr.real_output].second.dest));
  
                 LOG_ERROR("amount " << src_entr.amount << ", rct " << src_entr.rct);
                 LOG_ERROR("tx pubkey " << src_entr.real_out_tx_key << ", real_output_in_tx_index "
                                        << src_entr.real_output_in_tx_index);
                 return false;
             }
  
             //put key image into tx input
             txin_to_key input_to_key;
             input_to_key.amount = src_entr.amount;
             input_to_key.k_image = msout ? rct::rct2ki(src_entr.multisig_kLRki.ki) : img;
  
             //fill outputs array and use relative offsets
             for (const tx_source_entry::output_entry &out_entry: src_entr.outputs)
                 input_to_key.key_offsets.push_back(out_entry.first);
  
             input_to_key.key_offsets = absolute_output_offsets_to_relative(input_to_key.key_offsets);
             tx.vin.push_back(input_to_key);
         }
  
         // sort ins by their key image
         std::vector<size_t> ins_order(sources.size());
         for (size_t n = 0; n < sources.size(); ++n)
             ins_order[n] = n;
         std::sort(ins_order.begin(), ins_order.end(), [&](const size_t i0, const size_t i1) {
             const txin_to_key &tk0 = boost::get<txin_to_key>(tx.vin[i0]);
             const txin_to_key &tk1 = boost::get<txin_to_key>(tx.vin[i1]);
             return memcmp(&tk0.k_image, &tk1.k_image, sizeof(tk0.k_image)) > 0;
         });
         tools::apply_permutation(ins_order, [&] (size_t i0, size_t i1) {
             std::swap(tx.vin[i0], tx.vin[i1]);
             std::swap(in_contexts[i0], in_contexts[i1]);
             std::swap(sources[i0], sources[i1]);
         });
  
         if (shuffle_outs)
         {
             std::shuffle(destinations.begin(), destinations.end(), std::default_random_engine(crypto::rand<unsigned int>()));
         }
     } else{ // tx v3 onwards
         for (const tx_source_entry &src_entr : sources) {
             ++idx;
             summary_inputs_etn += src_entr.amount;
  
             txin_to_key_public input;
             input.amount = src_entr.amount;
             input.tx_hash = src_entr.tx_hash;
             input.relative_offset = src_entr.real_output_in_tx_index;
  
             tx.vin.push_back(input);
         }
     } //END OF WORK WITH INPUTS
  
     // figure out if we need to make additional tx pubkeys
     size_t num_stdaddresses = 0;
     size_t num_subaddresses = 0;
     account_public_address single_dest_subaddress;
     classify_addresses(destinations, change_addr, num_stdaddresses, num_subaddresses, single_dest_subaddress);
  
     // if this is a single-destination transfer to a subaddress, we set the tx pubkey to R=s*D
     //todo: 4.0.0.0
     if (num_stdaddresses == 0 && num_subaddresses == 1)
     {
       txkey_pub = rct::rct2pk(hwdev.scalarmultKey(rct::pk2rct(single_dest_subaddress.m_spend_public_key), rct::sk2rct(tx_key)));
     }
     else
     {
       txkey_pub = rct::rct2pk(hwdev.scalarmultBase(rct::sk2rct(tx_key)));
     }
     remove_field_from_tx_extra(tx.extra, typeid(tx_extra_pub_key));
     add_tx_pub_key_to_extra(tx, txkey_pub);
  
     std::vector<crypto::public_key> additional_tx_public_keys;
  
     // we don't need to include additional tx keys if:
     //   - all the destinations are standard addresses
     //   - there's only one destination which is a subaddress
     bool need_additional_txkeys = num_subaddresses > 0 && (num_stdaddresses > 0 || num_subaddresses > 1);
     if (need_additional_txkeys)
       CHECK_AND_ASSERT_MES(destinations.size() == additional_tx_keys.size(), false, "Wrong amount of additional tx keys");
  
     uint64_t summary_outs_etn = 0;
     //fill outputs
     size_t output_index = 0;
         for (const tx_destination_entry &dst_entr: destinations) {
             if(tx.version == 1) {
                 crypto::public_key out_eph_public_key;
  
                 hwdev.generate_output_ephemeral_keys(tx.version, sender_account_keys, txkey_pub, tx_key,
                                                      dst_entr, change_addr, output_index,
                                                      need_additional_txkeys, additional_tx_keys,
                                                      additional_tx_public_keys, amount_keys, out_eph_public_key);
  
                 tx_out out;
                 out.amount = dst_entr.amount;
                 txout_to_key tk;
                 tk.key = out_eph_public_key;
                 out.target = tk;
                 tx.vout.push_back(out);
                 output_index++;
                 summary_outs_etn += dst_entr.amount;
             }else{
                 tx_out out;
                 out.amount = dst_entr.amount;
                 txout_to_key_public tkp;
                 tkp.address.m_view_public_key = dst_entr.addr.m_view_public_key;
                 tkp.address.m_spend_public_key = dst_entr.addr.m_spend_public_key;
                 tkp.m_address_prefix = dst_entr.is_subaddress ?
                         get_config(nettype).CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX :
                                        get_config(nettype).CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX;
                 out.target = tkp;
                 tx.vout.push_back(out);
                 output_index++;
                 summary_outs_etn += dst_entr.amount;
             }
         }
  
     CHECK_AND_ASSERT_MES(additional_tx_public_keys.size() == additional_tx_keys.size(), false, "Internal error creating additional public keys");
  
     remove_field_from_tx_extra(tx.extra, typeid(tx_extra_additional_pub_keys));
  
     LOG_PRINT_L2("tx pubkey: " << txkey_pub);
     if (need_additional_txkeys)
     {
       LOG_PRINT_L2("additional tx pubkeys: ");
       for (size_t i = 0; i < additional_tx_public_keys.size(); ++i)
         LOG_PRINT_L2(additional_tx_public_keys[i]);
       add_additional_tx_pub_keys_to_extra(tx.extra, additional_tx_public_keys);
     }
  
     if (!sort_tx_extra(tx.extra, tx.extra))
       return false;
  
     //check etn
     if(summary_outs_etn > summary_inputs_etn )
     {
       LOG_ERROR("Transaction inputs ETN ("<< summary_inputs_etn << ") less than outputs ETN (" << summary_outs_etn << ")");
       return false;
     }
  
     // check for watch only wallet
     bool zero_secret_key = true;
     for (size_t i = 0; i < sizeof(sender_account_keys.m_spend_secret_key); ++i)
       zero_secret_key &= (sender_account_keys.m_spend_secret_key.data[i] == 0);
     if (zero_secret_key)
     {
       MDEBUG("Null secret key, skipping signatures");
     }
  
     //generate ring signatures
     crypto::hash tx_prefix_hash;
     hwdev.get_transaction_prefix_hash(tx, tx_prefix_hash);
  
     std::stringstream ss_ring_s;
     size_t i = 0;
     
     if(tx.version < 3)
     {
       for(const tx_source_entry& src_entr:  sources)
       {
         ss_ring_s << "pub_keys:" << ENDL;
         std::vector<const crypto::public_key *> keys_ptrs;
         std::vector<crypto::public_key> keys(src_entr.outputs.size());
         size_t ii = 0;
         for (const tx_source_entry::output_entry &o: src_entr.outputs) {
             keys[ii] = rct2pk(o.second.dest);
             keys_ptrs.push_back(&keys[ii]);
             ss_ring_s << o.second.dest << ENDL;
             ++ii;
         }
  
         tx.signatures.push_back(std::vector<crypto::signature>());
         std::vector<crypto::signature> &sigs = tx.signatures.back();
         sigs.resize(src_entr.outputs.size());
         if (!zero_secret_key)
             hwdev.generate_ring_signature(tx_prefix_hash, boost::get<txin_to_key>(tx.vin[i]).k_image, keys_ptrs,
                                           in_contexts[i].in_ephemeral.sec, src_entr.real_output, sigs.data());
         ss_ring_s << "signatures:" << ENDL;
         std::for_each(sigs.begin(), sigs.end(), [&](const crypto::signature &s) { ss_ring_s << s << ENDL; });
         ss_ring_s << "prefix_hash:" << tx_prefix_hash << ENDL << "in_ephemeral_key: "
                   << in_contexts[i].in_ephemeral.sec << ENDL << "real_output: " << src_entr.real_output << ENDL;
         i++;
  
         MCINFO("construct_tx",
               "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL
                                       << ss_ring_s.str());
       }
     }
     else
     { //new public signatures for v3 onwards
       for(uint64_t i = 0; i< tx.vin.size(); i++) {
         crypto::signature signature;
         std::vector<crypto::signature> signature_vec;
           if (!zero_secret_key) {
  
               subaddress_index input_subaddress_index = sources[i].subaddr_index;
               crypto::secret_key private_view_for_sig;
               crypto::secret_key private_spend_for_sig;
  
               if (input_subaddress_index.major == 0 && input_subaddress_index.minor == 0) {
                   private_view_for_sig = sender_account_keys.m_view_secret_key;
                   private_spend_for_sig = sender_account_keys.m_spend_secret_key;
               } else {
                   private_spend_for_sig = hwdev.get_subaddress_private_spendkey(sender_account_keys,
                                                                                 input_subaddress_index);
                   private_view_for_sig = hwdev.get_subaddress_private_viewkey(sender_account_keys.m_view_secret_key,
                                                                               private_spend_for_sig);
               }
  
               hwdev.generate_input_signature(
                       tx_prefix_hash,
                       i,
                       private_view_for_sig,
                       private_spend_for_sig,
                       signature
               );
           }
         signature_vec.push_back(signature);
         tx.signatures.push_back(signature_vec);
       }
  
       MCINFO("construct_tx",
               "transaction_created (v3): " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx));
     }
     
     tx.invalidate_hashes();
  
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose_amount_into_digits()

template<typename chunk_handler_t , typename dust_handler_t >

void cryptonote::decompose_amount_into_digits	(	uint64_t	amount,
		uint64_t	dust_threshold,
		const chunk_handler_t &	chunk_handler,
		const dust_handler_t &	dust_handler
	)

Definition at line 209 of file cryptonote_format_utils.h.

   {
     if (0 == amount)
     {
       return;
     }
  
     bool is_dust_handled = false;
     uint64_t dust = 0;
     uint64_t order = 1;
     while (0 != amount)
     {
       uint64_t chunk = (amount % 10) * order;
       amount /= 10;
       order *= 10;
  
       if (dust + chunk <= dust_threshold)
       {
         dust += chunk;
       }
       else
       {
         if (!is_dust_handled && 0 != dust)
         {
           dust_handler(dust);
           is_dust_handled = true;
         }
         if (0 != chunk)
         {
           chunk_handler(chunk);
         }
       }
     }
  
     if (!is_dust_handled && 0 != dust)
     {
       dust_handler(dust);
     }
   }

Here is the caller graph for this function:

◆ decrypt_key()

crypto::secret_key cryptonote::decrypt_key	(	crypto::secret_key	key,
		const epee::wipeable_string &	passphrase
	)

Definition at line 1304 of file cryptonote_format_utils.cpp.

   {
     crypto::hash hash;
     crypto::cn_slow_hash(passphrase.data(), passphrase.size(), hash);
     sc_sub((unsigned char*)key.data, (const unsigned char*)key.data, (const unsigned char*)hash.data);
     return key;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encrypt_key()

crypto::secret_key cryptonote::encrypt_key	(	crypto::secret_key	key,
		const epee::wipeable_string &	passphrase
	)

Definition at line 1296 of file cryptonote_format_utils.cpp.

   {
     crypto::hash hash;
     crypto::cn_slow_hash(passphrase.data(), passphrase.size(), hash);
     sc_add((unsigned char*)key.data, (const unsigned char*)key.data, (const unsigned char*)hash.data);
     return key;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ expand_transaction_1()

bool cryptonote::expand_transaction_1	(	transaction &	tx,
		bool	base_only
	)

Definition at line 128 of file cryptonote_format_utils.cpp.

   {
     return true;
   }

Here is the caller graph for this function:

◆ factorial()

double cryptonote::factorial ( unsigned int n )

Definition at line 1873 of file cryptonote_core.cpp.

   {
     if (n <= 1)
       return 1.0;
     double f = n;
     while (n-- > 1)
       f *= n;
     return f;
   }

◆ find_tx_extra_field_by_type()

template<typename T >

bool cryptonote::find_tx_extra_field_by_type	(	const std::vector< tx_extra_field > &	tx_extra_fields,
		T &	field,
		size_t	index = `0`
	)

Definition at line 62 of file cryptonote_format_utils.h.

   {
     auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; }); // ie index only decremented IF we fiind the right type
     if(tx_extra_fields.end() == it)
       return false;
  
     field = boost::get<T>(*it);
     return true;
   }

Here is the caller graph for this function:

◆ generate_genesis_block()

bool cryptonote::generate_genesis_block	(	block &	bl,
		std::string const &	genesis_tx,
		uint32_t	nonce
	)

Definition at line 613 of file cryptonote_tx_utils.cpp.

   {
     //genesis block
     bl = boost::value_initialized<block>();
  
  
     account_public_address ac = boost::value_initialized<account_public_address>();
     std::vector<size_t> sz;
     construct_miner_tx(0, 0, 0, 0, 0, ac, bl.miner_tx); // zero fee in genesis
     blobdata txb = tx_to_blob(bl.miner_tx);
     std::string hex_tx_represent = string_tools::buff_to_hex_nodelimer(txb);
  
     std::string genesis_coinbase_tx_hex = genesis_tx;
  
     blobdata tx_bl;
     bool r = string_tools::parse_hexstr_to_binbuff(genesis_tx, tx_bl);
     CHECK_AND_ASSERT_MES(r, false, "failed to parse coinbase tx from hard coded blob");
     r = parse_and_validate_tx_from_blob(tx_bl, bl.miner_tx);
     CHECK_AND_ASSERT_MES(r, false, "failed to parse coinbase tx from hard coded blob");
     bl.major_version = CURRENT_BLOCK_MAJOR_VERSION;
     bl.minor_version = CURRENT_BLOCK_MINOR_VERSION;
     bl.timestamp = 0;
     bl.nonce = nonce;
     miner::find_nonce_for_given_block(bl, 1, 0);
     bl.invalidate_hashes();
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_key_image_helper()

bool cryptonote::generate_key_image_helper	(	const account_keys &	ack,
		const std::unordered_map< crypto::public_key, subaddress_index > &	subaddresses,
		const crypto::public_key &	out_key,
		const crypto::public_key &	tx_public_key,
		const std::vector< crypto::public_key > &	additional_tx_public_keys,
		size_t	real_output_index,
		keypair &	in_ephemeral,
		crypto::key_image &	ki,
		hw::device &	hwdev,
		const uint32_t	account_major_offset
	)

Definition at line 208 of file cryptonote_format_utils.cpp.

   {
     crypto::key_derivation recv_derivation = AUTO_VAL_INIT(recv_derivation);
     bool r = hwdev.generate_key_derivation(tx_public_key, ack.m_view_secret_key, recv_derivation);
     if (!r)
     {
       MWARNING("key image helper: failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
       memcpy(&recv_derivation, rct::identity().bytes, sizeof(recv_derivation));
     }
  
     std::vector<crypto::key_derivation> additional_recv_derivations;
     for (size_t i = 0; i < additional_tx_public_keys.size(); ++i)
     {
       crypto::key_derivation additional_recv_derivation = AUTO_VAL_INIT(additional_recv_derivation);
       r = hwdev.generate_key_derivation(additional_tx_public_keys[i], ack.m_view_secret_key, additional_recv_derivation);
       if (!r)
       {
         MWARNING("key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", " << ack.m_view_secret_key << ")");
       }
       else
       {
         additional_recv_derivations.push_back(additional_recv_derivation);
       }
     }
  
     boost::optional<subaddress_receive_info> subaddr_recv_info = is_out_to_acc_precomp(subaddresses, out_key, recv_derivation, additional_recv_derivations, real_output_index,hwdev);
     CHECK_AND_ASSERT_MES(subaddr_recv_info, false, "key image helper: given output pubkey doesn't seem to belong to this address");
  
     return generate_key_image_helper_precomp(ack, out_key, subaddr_recv_info->derivation, real_output_index, subaddr_recv_info->index, in_ephemeral, ki, hwdev, account_major_offset);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_key_image_helper_precomp()

bool cryptonote::generate_key_image_helper_precomp	(	const account_keys &	ack,
		const crypto::public_key &	out_key,
		const crypto::key_derivation &	recv_derivation,
		size_t	real_output_index,
		const subaddress_index &	received_index,
		keypair &	in_ephemeral,
		crypto::key_image &	ki,
		hw::device &	hwdev,
		const uint32_t	account_major_offset
	)

Definition at line 239 of file cryptonote_format_utils.cpp.

   {
     uint32_t major_index_offset_based = received_index.major + (received_index.major != 0 ? account_major_offset : 0);
     cryptonote::subaddress_index recv_index = {major_index_offset_based, received_index.minor};
  
     if (hwdev.compute_key_image(ack, out_key, recv_derivation, real_output_index, recv_index, in_ephemeral, ki))
     {
       return true;
     }
  
     if (ack.m_spend_secret_key == crypto::null_skey)
     {
       // for watch-only wallet, simply copy the known output pubkey
       in_ephemeral.pub = out_key;
       in_ephemeral.sec = crypto::null_skey;
     }
     else
     {
       // derive secret key with subaddress - step 1: original CN derivation
       crypto::secret_key scalar_step1;
       hwdev.derive_secret_key(recv_derivation, real_output_index, ack.m_spend_secret_key, scalar_step1); // computes Hs(a*R || idx) + b
  
       // step 2: add Hs(a || index_major || index_minor)
       crypto::secret_key subaddr_sk;
       crypto::secret_key scalar_step2;
       if (recv_index.is_zero())
       {
         scalar_step2 = scalar_step1;    // treat index=(0,0) as a special case representing the main address
       }
       else
       {
         subaddr_sk = hwdev.get_subaddress_secret_key(ack.m_view_secret_key, recv_index);
         hwdev.sc_secret_add(scalar_step2, scalar_step1,subaddr_sk);
       }
  
       in_ephemeral.sec = scalar_step2;
  
       if (ack.m_multisig_keys.empty())
       {
         // when not in multisig, we know the full spend secret key, so the output pubkey can be obtained by scalarmultBase
         CHECK_AND_ASSERT_MES(hwdev.secret_key_to_public_key(in_ephemeral.sec, in_ephemeral.pub), false, "Failed to derive public key");
       }
       else
       {
         // when in multisig, we only know the partial spend secret key. but we do know the full spend public key, so the output pubkey can be obtained by using the standard CN key derivation
         CHECK_AND_ASSERT_MES(hwdev.derive_public_key(recv_derivation, real_output_index, ack.m_account_address.m_spend_public_key, in_ephemeral.pub), false, "Failed to derive public key");
         // and don't forget to add the contribution from the subaddress part
         if (!recv_index.is_zero())
         {
           crypto::public_key subaddr_pk;
           CHECK_AND_ASSERT_MES(hwdev.secret_key_to_public_key(subaddr_sk, subaddr_pk), false, "Failed to derive public key");
           add_public_key(in_ephemeral.pub, in_ephemeral.pub, subaddr_pk);
         }
       }
  
       CHECK_AND_ASSERT_MES(in_ephemeral.pub == out_key,
            false, "key image helper precomp: given output pubkey doesn't match the derived one");
     }
  
     hwdev.generate_key_image(in_ephemeral.pub, in_ephemeral.sec, ki);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_multisig_composite_key_image()

bool cryptonote::generate_multisig_composite_key_image	(	const account_keys &	keys,
		const std::unordered_map< crypto::public_key, subaddress_index > &	subaddresses,
		const crypto::public_key &	out_key,
		const crypto::public_key &	tx_public_key,
		const std::vector< crypto::public_key > &	additional_tx_public_keys,
		size_t	real_output_index,
		const std::vector< crypto::key_image > &	pkis,
		crypto::key_image &	ki
	)

Definition at line 156 of file multisig.cpp.

   {
     cryptonote::keypair in_ephemeral;
     if (!cryptonote::generate_key_image_helper(keys, subaddresses, out_key, tx_public_key, additional_tx_public_keys, real_output_index, in_ephemeral, ki, keys.get_device()))
       return false;
     std::unordered_set<crypto::key_image> used;
     for (size_t m = 0; m < keys.m_multisig_keys.size(); ++m)
     {
       crypto::key_image pki;
       bool r = cryptonote::generate_multisig_key_image(keys, m, out_key, pki);
       if (!r)
         return false;
       used.insert(pki);
     }
     for (const auto &pki: pkis)
     {
       if (used.find(pki) == used.end())
       {
         used.insert(pki);
         rct::addKeys((rct::key&)ki, rct::ki2rct(ki), rct::ki2rct(pki));
       }
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_multisig_derivations()

std::vector< crypto::public_key > cryptonote::generate_multisig_derivations	(	const account_keys &	keys,
		const std::vector< crypto::public_key > &	derivations
	)

generate_multisig_derivations performs common DH key derivation. Each middle round in M/N scheme is DH exchange of public multisig keys of other participants multiplied by secret spend key of current participant. this functions does the following: new multisig key = secret spend * public multisig key

Parameters

keys	- current wallet's keys
derivations	- public multisig keys of other participants

Returns: new public multisig keys derived from previous round. This data needs to be exchange with other participants

Definition at line 87 of file multisig.cpp.

   {
     std::vector<crypto::public_key> multisig_keys;
     crypto::secret_key blinded_skey = get_multisig_blinded_secret_key(keys.m_spend_secret_key);
     for (const auto &k: derivations)
     {
       rct::key d = rct::scalarmultKey(rct::pk2rct(k), rct::sk2rct(blinded_skey));
       multisig_keys.push_back(rct::rct2pk(d));
     }
  
     return multisig_keys;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_multisig_key_image()

bool cryptonote::generate_multisig_key_image	(	const account_keys &	keys,
		size_t	multisig_key_index,
		const crypto::public_key &	out_key,
		crypto::key_image &	ki
	)

Definition at line 142 of file multisig.cpp.

   {
     if (multisig_key_index >= keys.m_multisig_keys.size())
       return false;
     crypto::generate_key_image(out_key, keys.m_multisig_keys[multisig_key_index], ki);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_multisig_LR()

void cryptonote::generate_multisig_LR	(	const crypto::public_key	pkey,
		const crypto::secret_key &	k,
		crypto::public_key &	L,
		crypto::public_key &	R
	)

Definition at line 150 of file multisig.cpp.

   {
     rct::scalarmultBase((rct::key&)L, rct::sk2rct(k));
     crypto::generate_key_image(pkey, k, (crypto::key_image&)R);
   }

Here is the caller graph for this function:

◆ generate_multisig_M_N_spend_public_key()

crypto::public_key cryptonote::generate_multisig_M_N_spend_public_key ( const std::vector< crypto::public_key > & pkeys )

generate_multisig_M_N_spend_public_key calculates multisig wallet's spend public key by summing all of public multisig keys

Parameters

pkeys unique public multisig keys

Returns: multisig wallet's spend public key

Definition at line 132 of file multisig.cpp.

   {
     rct::key spend_public_key = rct::identity();
     for (const auto &pk: pkeys)
     {
       rct::addKeys(spend_public_key, spend_public_key, rct::pk2rct(pk));
     }
     return rct::rct2pk(spend_public_key);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_multisig_N1_N()

void cryptonote::generate_multisig_N1_N	(	const account_keys &	keys,
		const std::vector< crypto::public_key > &	spend_keys,
		std::vector< crypto::secret_key > &	multisig_keys,
		rct::key &	spend_skey,
		rct::key &	spend_pkey
	)

Definition at line 70 of file multisig.cpp.

   {
     multisig_keys.clear();
     spend_pkey = rct::identity();
     spend_skey = rct::zero();
  
     // create all our composite private keys
     crypto::secret_key blinded_skey = get_multisig_blinded_secret_key(keys.m_spend_secret_key);
     for (const auto &k: spend_keys)
     {
       rct::key sk = rct::scalarmultKey(rct::pk2rct(k), rct::sk2rct(blinded_skey));
       crypto::secret_key msk = get_multisig_blinded_secret_key(rct::rct2sk(sk));
       multisig_keys.push_back(msk);
       sc_add(spend_skey.bytes, spend_skey.bytes, (const unsigned char*)msk.data);
     }
   }

Here is the call graph for this function:

◆ generate_multisig_N_N()

void cryptonote::generate_multisig_N_N	(	const account_keys &	keys,
		const std::vector< crypto::public_key > &	spend_keys,
		std::vector< crypto::secret_key > &	multisig_keys,
		rct::key &	spend_skey,
		rct::key &	spend_pkey
	)

Definition at line 58 of file multisig.cpp.

   {
     // the multisig spend public key is the sum of all spend public keys
     multisig_keys.clear();
     const crypto::secret_key spend_secret_key = get_multisig_blinded_secret_key(keys.m_spend_secret_key);
     CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(spend_secret_key, (crypto::public_key&)spend_pkey), "Failed to derive public key");
     for (const auto &k: spend_keys)
       rct::addKeys(spend_pkey, spend_pkey, rct::pk2rct(k));
     multisig_keys.push_back(spend_secret_key);
     spend_skey = rct::sk2rct(spend_secret_key);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_multisig_view_secret_key()

crypto::secret_key cryptonote::generate_multisig_view_secret_key	(	const crypto::secret_key &	skey,
		const std::vector< crypto::secret_key > &	skeys
	)

Definition at line 124 of file multisig.cpp.

   {
     rct::key view_skey = rct::sk2rct(get_multisig_blinded_secret_key(skey));
     for (const auto &k: skeys)
       sc_add(view_skey.bytes, view_skey.bytes, rct::sk2rct(k).bytes);
     return rct::rct2sk(view_skey);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_output_ephemeral_keys()

bool cryptonote::generate_output_ephemeral_keys	(	const size_t	tx_version,
		const cryptonote::account_keys &	sender_account_keys,
		const crypto::public_key &	txkey_pub,
		const crypto::secret_key &	tx_key,
		const cryptonote::tx_destination_entry &	dst_entr,
		const boost::optional< cryptonote::account_public_address > &	change_addr,
		const size_t	output_index,
		const bool &	need_additional_txkeys,
		const std::vector< crypto::secret_key > &	additional_tx_keys,
		std::vector< crypto::public_key > &	additional_tx_public_keys,
		std::vector< rct::key > &	amount_keys,
		crypto::public_key &	out_eph_public_key
	)

◆ get_account_address_as_str()

std::string cryptonote::get_account_address_as_str	(	network_type	nettype,
		bool	subaddress,
		account_public_address const &	adr
	)

Definition at line 207 of file cryptonote_basic_impl.cpp.

   {
     uint64_t address_prefix = subaddress ? get_config(nettype).CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX : get_config(nettype).CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX;
  
     return tools::base58::encode_addr(address_prefix, t_serializable_object_to_blob(adr));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_account_address_checksum()

uint8_t cryptonote::get_account_address_checksum ( const public_address_outer_blob & bl )

Definition at line 187 of file cryptonote_basic_impl.cpp.

   {
     const unsigned char* pbuf = reinterpret_cast<const unsigned char*>(&bl);
     uint8_t summ = 0;
     for(size_t i = 0; i!= sizeof(public_address_outer_blob)-1; i++)
       summ += pbuf[i];
  
     return summ;
   }

Here is the caller graph for this function:

◆ get_account_address_from_str()

bool cryptonote::get_account_address_from_str	(	address_parse_info &	info,
		network_type	nettype,
		std::string const &	str
	)

Definition at line 243 of file cryptonote_basic_impl.cpp.

   {
     uint64_t address_prefix = get_config(nettype).CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX;
     uint64_t integrated_address_prefix = get_config(nettype).CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX;
     uint64_t subaddress_prefix = get_config(nettype).CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX;
  
     if (2 * sizeof(public_address_outer_blob) != str.size())
     {
       blobdata data;
       uint64_t prefix;
       if (!tools::base58::decode_addr(str, prefix, data))
       {
         LOG_PRINT_L2("Invalid address format");
         return false;
       }
  
       if (integrated_address_prefix == prefix)
       {
         info.is_subaddress = false;
         info.has_payment_id = true;
       }
       else if (address_prefix == prefix)
       {
         info.is_subaddress = false;
         info.has_payment_id = false;
       }
       else if (subaddress_prefix == prefix)
       {
         info.is_subaddress = true;
         info.has_payment_id = false;
       }
       else {
         LOG_PRINT_L1("Wrong address prefix: " << prefix << ", expected " << address_prefix 
           << " or " << integrated_address_prefix
           << " or " << subaddress_prefix);
         return false;
       }
  
       if (info.has_payment_id)
       {
         integrated_address iadr;
         if (!::serialization::parse_binary(data, iadr))
         {
           LOG_PRINT_L1("Account public address keys can't be parsed");
           return false;
         }
         info.address = iadr.adr;
         info.payment_id = iadr.payment_id;
       }
       else
       {
         if (!::serialization::parse_binary(data, info.address))
         {
           LOG_PRINT_L1("Account public address keys can't be parsed");
           return false;
         }
       }
  
       if (!crypto::check_key(info.address.m_spend_public_key) || !crypto::check_key(info.address.m_view_public_key))
       {
         LOG_PRINT_L1("Failed to validate address keys");
         return false;
       }
     }
     else
     {
       // Old address format
       std::string buff;
       if(!string_tools::parse_hexstr_to_binbuff(str, buff))
         return false;
  
       if(buff.size()!=sizeof(public_address_outer_blob))
       {
         LOG_PRINT_L1("Wrong public address size: " << buff.size() << ", expected size: " << sizeof(public_address_outer_blob));
         return false;
       }
  
       public_address_outer_blob blob = *reinterpret_cast<const public_address_outer_blob*>(buff.data());
  
  
       if(blob.m_ver > CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER)
       {
         LOG_PRINT_L1("Unknown version of public address: " << blob.m_ver << ", expected " << CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER);
         return false;
       }
  
       if(blob.check_sum != get_account_address_checksum(blob))
       {
         LOG_PRINT_L1("Wrong public address checksum");
         return false;
       }
  
       //we success
       info.address = blob.m_address;
       info.is_subaddress = false;
       info.has_payment_id = false;
     }
  
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_account_address_from_str_or_url()

bool cryptonote::get_account_address_from_str_or_url	(	address_parse_info &	info,
		network_type	nettype,
		const std::string &	str_or_url,
		std::function< std::string(const std::string &, const std::vector< std::string > &, bool)>	dns_confirm
	)

Definition at line 348 of file cryptonote_basic_impl.cpp.

   {
     if (get_account_address_from_str(info, nettype, str_or_url))
       return true;
     bool dnssec_valid;
     std::string address_str = tools::dns_utils::get_account_address_as_str_from_url(str_or_url, dnssec_valid, dns_confirm);
     return !address_str.empty() &&
       get_account_address_from_str(info, nettype, address_str);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_account_integrated_address_as_str()

std::string cryptonote::get_account_integrated_address_as_str	(	network_type	nettype,
		account_public_address const &	adr,
		crypto::hash8 const &	payment_id
	)

Definition at line 218 of file cryptonote_basic_impl.cpp.

   {
     uint64_t integrated_address_prefix = get_config(nettype).CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX;
  
     integrated_address iadr = {
       adr, payment_id
     };
     return tools::base58::encode_addr(integrated_address_prefix, t_serializable_object_to_blob(iadr));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_account_integrated_address_checksum()

uint8_t cryptonote::get_account_integrated_address_checksum ( const public_integrated_address_outer_blob & bl )

Definition at line 197 of file cryptonote_basic_impl.cpp.

   {
     const unsigned char* pbuf = reinterpret_cast<const unsigned char*>(&bl);
     uint8_t summ = 0;
     for(size_t i = 0; i!= sizeof(public_integrated_address_outer_blob)-1; i++)
       summ += pbuf[i];
  
     return summ;
   }

◆ get_additional_tx_pub_keys_from_extra() [1/2]

std::vector< crypto::public_key > cryptonote::get_additional_tx_pub_keys_from_extra ( const std::vector< uint8_t > & tx_extra )

Definition at line 555 of file cryptonote_format_utils.cpp.

   {
     // parse
     std::vector<tx_extra_field> tx_extra_fields;
     parse_tx_extra(tx_extra, tx_extra_fields);
     // find corresponding field
     tx_extra_additional_pub_keys additional_pub_keys;
     if(!find_tx_extra_field_by_type(tx_extra_fields, additional_pub_keys))
       return {};
     return additional_pub_keys.data;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_additional_tx_pub_keys_from_extra() [2/2]

std::vector< crypto::public_key > cryptonote::get_additional_tx_pub_keys_from_extra ( const transaction_prefix & tx )

Definition at line 567 of file cryptonote_format_utils.cpp.

   {
     return get_additional_tx_pub_keys_from_extra(tx.extra);
   }

Here is the caller graph for this function:

◆ get_blob_hash() [1/4]

crypto::hash cryptonote::get_blob_hash ( const blobdata & blob )

Definition at line 948 of file cryptonote_format_utils.cpp.

   {
     crypto::hash h = null_hash;
     get_blob_hash(blob, h);
     return h;
   }

◆ get_blob_hash() [2/4]

void cryptonote::get_blob_hash	(	const blobdata &	blob,
		crypto::hash &	res
	)

Definition at line 897 of file cryptonote_format_utils.cpp.

   {
     cn_fast_hash(blob.data(), blob.size(), res);
   }

Here is the call graph for this function:

◆ get_blob_hash() [3/4]

crypto::hash cryptonote::get_blob_hash ( const epee::span< const char > & blob )

Definition at line 955 of file cryptonote_format_utils.cpp.

   {
     crypto::hash h = null_hash;
     get_blob_hash(blob, h);
     return h;
   }

◆ get_blob_hash() [4/4]

void cryptonote::get_blob_hash	(	const epee::span< const char > &	blob,
		crypto::hash &	res
	)

Definition at line 892 of file cryptonote_format_utils.cpp.

   {
     cn_fast_hash(blob.data(), blob.size(), res);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_complete_entry()

block_complete_entry cryptonote::get_block_complete_entry	(	block &	b,
		tx_memory_pool &	pool
	)

Definition at line 1357 of file cryptonote_core.cpp.

   {
     block_complete_entry bce;
     bce.block = cryptonote::block_to_blob(b);
     for (const auto &tx_hash: b.tx_hashes)
     {
       cryptonote::blobdata txblob;
       CHECK_AND_ASSERT_THROW_MES(pool.get_transaction(tx_hash, txblob), "Transaction not found in pool");
       bce.txs.push_back(txblob);
     }
     return bce;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_hash() [1/2]

crypto::hash cryptonote::get_block_hash ( const block & b )

Definition at line 1165 of file cryptonote_format_utils.cpp.

   {
     crypto::hash p = null_hash;
     get_block_hash(b, p);
     return p;
   }

◆ get_block_hash() [2/2]

bool cryptonote::get_block_hash	(	const block &	b,
		crypto::hash &	res
	)

Definition at line 1145 of file cryptonote_format_utils.cpp.

   {
     if (b.is_hash_valid())
     {
 #ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
       CHECK_AND_ASSERT_THROW_MES(!calculate_block_hash(b, res) || b.hash == res, "block hash cash integrity failure");
 #endif
       res = b.hash;
       ++block_hashes_cached_count;
       return true;
     }
     ++block_hashes_calculated_count;
     bool ret = calculate_block_hash(b, res);
     if (!ret)
       return false;
     b.hash = res;
     b.set_hash_valid(true);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_hashing_blob()

blobdata cryptonote::get_block_hashing_blob ( const block & b )

Definition at line 1131 of file cryptonote_format_utils.cpp.

   {
     blobdata blob = t_serializable_object_to_blob(static_cast<block_header>(b));
     crypto::hash tree_root_hash = get_tx_tree_hash(b);
     blob.append(reinterpret_cast<const char*>(&tree_root_hash), sizeof(tree_root_hash));
     blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
     return blob;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_height()

uint64_t cryptonote::get_block_height ( const block & b )

Definition at line 694 of file cryptonote_format_utils.cpp.

   {
     CHECK_AND_ASSERT_MES(b.miner_tx.vin.size() == 1, 0, "wrong miner tx in block: " << get_block_hash(b) << ", b.miner_tx.vin.size() != 1");
     CHECKED_GET_SPECIFIC_VARIANT(b.miner_tx.vin[0], const txin_gen, coinbase_in, 0);
     return coinbase_in.height;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_longhash() [1/2]

bool cryptonote::get_block_longhash	(	const block &	b,
		crypto::hash &	res,
		uint64_t	height
	)

Definition at line 1172 of file cryptonote_format_utils.cpp.

   {
     blobdata bd = get_block_hashing_blob(b);
     const int cn_variant = b.major_version == 6 ? b.major_version - 5 : 0; // Emergency HF so anti-asic is only if HF 6
     crypto::cn_slow_hash(bd.data(), bd.size(), res, cn_variant);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_longhash() [2/2]

crypto::hash cryptonote::get_block_longhash	(	const block &	b,
		uint64_t	height
	)

Definition at line 1200 of file cryptonote_format_utils.cpp.

   {
     crypto::hash p = null_hash;
     get_block_longhash(b, p, height);
     return p;
   }

◆ get_block_reward()

bool cryptonote::get_block_reward	(	size_t	median_weight,
		size_t	current_block_weight,
		uint64_t	already_generated_coins,
		uint64_t &	reward,
		uint8_t	version,
		uint64_t	current_block_height,
		network_type	nettype
	)

Definition at line 91 of file cryptonote_basic_impl.cpp.

                                                                                                                                                                                                      {
     static_assert(DIFFICULTY_TARGET%60==0,"difficulty target must be a multiple of 60");
     static_assert(DIFFICULTY_TARGET_V6%60==0,"difficulty target V6 must be a multiple of 60");
  
     const int target = version >= 6 ? DIFFICULTY_TARGET_V6 : DIFFICULTY_TARGET;
  
     const int target_minutes = target / 60;
  
     uint64_t full_reward_zone = get_min_block_weight(version);
  
     const uint64_t premine = 1260000000000U;
     if (median_weight > 0 && already_generated_coins < premine && !(current_block_weight >= 2 * full_reward_zone)) {
       reward = premine;
       return true;
     }
  
     uint64_t base_reward;
  
     // After v9 the reward drops by ~75%, fixed reward curve that halves every 4 years (up to 2 halvings)
     if(version >= 9) {
  
       uint64_t V9_BLOCK_HEIGHT = 0;
       switch(nettype) {
         case MAINNET:
           V9_BLOCK_HEIGHT = 862866;
           break;
         case TESTNET:
           V9_BLOCK_HEIGHT = 707121;
           break;
         case STAGENET:
           V9_BLOCK_HEIGHT = 39000;
           break;
         default:
           V9_BLOCK_HEIGHT = 39000;
       }
  
       base_reward = version >= 10 ? 100 * COIN : 400 * COIN;
       uint8_t halvings = (current_block_height - V9_BLOCK_HEIGHT) / 1051200; // Every 4 years
  
       // Tail emission after 2nd halving
       if (halvings > 2) {
  
         //Force 2x tail emission after 2nd halving if circulating supply < max supply
         base_reward = (already_generated_coins >= ETN_SUPPLY) ? FINAL_SUBSIDY_PER_MINUTE : FINAL_SUBSIDY_PER_MINUTE * 2;
  
       } else {
         base_reward >>= halvings;
       }
     } else {
       //After v8 the reward drops by ~75%
       double emission_speed_factor = (version == 8 ? EMISSION_SPEED_FACTOR_PER_MINUTE_V8 : EMISSION_SPEED_FACTOR_PER_MINUTE) - (target_minutes-1);
  
       base_reward = (ETN_SUPPLY - already_generated_coins) / pow(2, emission_speed_factor);
  
       if (base_reward < FINAL_SUBSIDY_PER_MINUTE*target_minutes)
       {
         base_reward = FINAL_SUBSIDY_PER_MINUTE*target_minutes;
       }
     }
  
     //make it soft
     if (median_weight < full_reward_zone) {
       median_weight = full_reward_zone;
     }
  
     if (current_block_weight <= median_weight) {
       reward = base_reward;
       return true;
     }
  
     if(current_block_weight > 2 * median_weight) {
       MERROR("Block cumulative weight is too big: " << current_block_weight << ", expected less than " << 2 * median_weight);
       return false;
     }
  
     assert(median_weight < std::numeric_limits<uint32_t>::max());
     assert(current_block_weight < std::numeric_limits<uint32_t>::max());
  
     uint64_t product_hi;
     // BUGFIX: 32-bit saturation bug (e.g. ARM7), the result was being
     // treated as 32-bit by default.
     uint64_t multiplicand = 2 * median_weight - current_block_weight;
     multiplicand *= current_block_weight;
     uint64_t product_lo = mul128(base_reward, multiplicand, &product_hi);
  
     uint64_t reward_hi;
     uint64_t reward_lo;
     div128_32(product_hi, product_lo, static_cast<uint32_t>(median_weight), &reward_hi, &reward_lo);
     div128_32(reward_hi, reward_lo, static_cast<uint32_t>(median_weight), &reward_hi, &reward_lo);
     assert(0 == reward_hi);
     assert(reward_lo < base_reward);
  
     reward = reward_lo;
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_config()

const config_t& cryptonote::get_config ( network_type nettype )

inline

Definition at line 264 of file cryptonote_config.h.

   {
     static const config_t mainnet = {
       ::config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
       ::config::CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX,
       ::config::CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX,
       ::config::P2P_DEFAULT_PORT,
       ::config::RPC_DEFAULT_PORT,
       ::config::ZMQ_RPC_DEFAULT_PORT,
       ::config::NETWORK_ID,
       ::config::GENESIS_TX,
       ::config::GENESIS_NONCE
     };
     static const config_t testnet = {
       ::config::testnet::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
       ::config::testnet::CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX,
       ::config::testnet::CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX,
       ::config::testnet::P2P_DEFAULT_PORT,
       ::config::testnet::RPC_DEFAULT_PORT,
       ::config::testnet::ZMQ_RPC_DEFAULT_PORT,
       ::config::testnet::NETWORK_ID,
       ::config::testnet::GENESIS_TX,
       ::config::testnet::GENESIS_NONCE
     };
     static const config_t stagenet = {
       ::config::stagenet::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
       ::config::stagenet::CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX,
       ::config::stagenet::CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX,
       ::config::stagenet::P2P_DEFAULT_PORT,
       ::config::stagenet::RPC_DEFAULT_PORT,
       ::config::stagenet::ZMQ_RPC_DEFAULT_PORT,
       ::config::stagenet::NETWORK_ID,
       ::config::stagenet::GENESIS_TX,
       ::config::stagenet::GENESIS_NONCE
     };
     switch (nettype)
     {
       case MAINNET: return mainnet;
       case TESTNET: return testnet;
       case STAGENET: return stagenet;
       case FAKECHAIN: return mainnet;
       default: throw std::runtime_error("Invalid network type");
     }
   };

Here is the caller graph for this function:

◆ get_default_decimal_point()

unsigned int cryptonote::get_default_decimal_point ( )

Definition at line 914 of file cryptonote_format_utils.cpp.

   {
     return default_decimal_point;
   }

◆ get_destination_view_key_pub()

crypto::public_key cryptonote::get_destination_view_key_pub	(	const std::vector< tx_destination_entry > &	destinations,
		const boost::optional< cryptonote::account_public_address > &	change_addr
	)

Definition at line 198 of file cryptonote_tx_utils.cpp.

   {
     account_public_address addr = {null_pkey, null_pkey};
     size_t count = 0;
     for (const auto &i : destinations)
     {
       if (i.amount == 0)
         continue;
       if (change_addr && i.addr == *change_addr)
         continue;
       if (i.addr == addr)
         continue;
       if (count > 0)
         return null_pkey;
       addr = i.addr;
       ++count;
     }
     if (count == 0 && change_addr)
       return change_addr->m_view_public_key;
     return addr.m_view_public_key;
   }

Here is the call graph for this function:

◆ get_encrypted_payment_id_from_tx_extra_nonce()

bool cryptonote::get_encrypted_payment_id_from_tx_extra_nonce	(	const blobdata &	extra_nonce,
		crypto::hash8 &	payment_id
	)

Definition at line 662 of file cryptonote_format_utils.cpp.

   {
     if(sizeof(crypto::hash8) + 1 != extra_nonce.size())
       return false;
     if (TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID != extra_nonce[0])
       return false;
     payment_id = *reinterpret_cast<const crypto::hash8*>(extra_nonce.data() + 1);
     return true;
   }

Here is the caller graph for this function:

◆ get_hash_stats()

void cryptonote::get_hash_stats	(	uint64_t &	tx_hashes_calculated,
		uint64_t &	tx_hashes_cached,
		uint64_t &	block_hashes_calculated,
		uint64_t &	block_hashes_cached
	)

Definition at line 1288 of file cryptonote_format_utils.cpp.

   {
     tx_hashes_calculated = tx_hashes_calculated_count;
     tx_hashes_cached = tx_hashes_cached_count;
     block_hashes_calculated = block_hashes_calculated_count;
     block_hashes_cached = block_hashes_cached_count;
   }

◆ get_inputs_etn_amount()

bool cryptonote::get_inputs_etn_amount	(	const transaction &	tx,
		uint64_t &	etn
	)

Definition at line 672 of file cryptonote_format_utils.cpp.

   {
     etn = 0;
     if(tx.version == 1 || tx.version == 2) {
       for(const auto& in: tx.vin)
       {
         CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
         etn += tokey_in.amount;
       }
     }
     else //tx.version >= 3 (public transactions: can spend only new inputs)
     {
       for(const auto& in: tx.vin)
       {
         CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key_public, tokey_in, false);
         etn += tokey_in.amount;
       }
     }
  
     return true;
   }

Here is the caller graph for this function:

◆ get_max_tx_size()

size_t cryptonote::get_max_tx_size ( )

Definition at line 86 of file cryptonote_basic_impl.cpp.

   {
     return CRYPTONOTE_MAX_TX_SIZE;
   }

◆ get_min_block_weight()

size_t cryptonote::get_min_block_weight ( uint8_t version )

Definition at line 73 of file cryptonote_basic_impl.cpp.

   {
     if (version < 2)
       return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1;
     if (version < 5)
       return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2;
     if (version < 8)
       return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5;
     if (version < 10)
       return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V8;
     return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V10;
   }

Here is the caller graph for this function:

◆ get_multisig_blinded_secret_key()

crypto::secret_key cryptonote::get_multisig_blinded_secret_key ( const crypto::secret_key & key )

Definition at line 47 of file multisig.cpp.

   {
     rct::keyV data;
     data.reserve(2);
     data.push_back(rct::sk2rct(key));
     data.push_back(multisig_salt);
     crypto::secret_key result = rct::rct2sk(rct::hash_to_scalar(data));
     memwipe(&data[0], sizeof(rct::key));
     return result;
   }

Here is the caller graph for this function:

◆ get_object_blobsize()

template<class t_object >

size_t cryptonote::get_object_blobsize ( const t_object & o )

Definition at line 182 of file cryptonote_format_utils.h.

   {
     blobdata b = t_serializable_object_to_blob(o);
     return b.size();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_object_hash() [1/2]

template<class t_object >

bool cryptonote::get_object_hash	(	const t_object &	o,
		crypto::hash &	res
	)

Definition at line 175 of file cryptonote_format_utils.h.

   {
     get_blob_hash(t_serializable_object_to_blob(o), res);
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_object_hash() [2/2]

template<class t_object >

bool cryptonote::get_object_hash	(	const t_object &	o,
		crypto::hash &	res,
		size_t &	blob_size
	)

Definition at line 189 of file cryptonote_format_utils.h.

   {
     blobdata bl = t_serializable_object_to_blob(o);
     blob_size = bl.size();
     get_blob_hash(bl, res);
     return true;
   }

Here is the call graph for this function:

◆ get_outs_etn_amount()

uint64_t cryptonote::get_outs_etn_amount ( const transaction & tx )

Definition at line 795 of file cryptonote_format_utils.cpp.

   {
     uint64_t outputs_amount = 0;
     for(const auto& o: tx.vout)
       outputs_amount += o.amount;
     return outputs_amount;
   }

Here is the caller graph for this function:

◆ get_payment_id_from_tx_extra_nonce()

bool cryptonote::get_payment_id_from_tx_extra_nonce	(	const blobdata &	extra_nonce,
		crypto::hash &	payment_id
	)

Definition at line 652 of file cryptonote_format_utils.cpp.

   {
     if(sizeof(crypto::hash) + 1 != extra_nonce.size())
       return false;
     if(TX_EXTRA_NONCE_PAYMENT_ID != extra_nonce[0])
       return false;
     payment_id = *reinterpret_cast<const crypto::hash*>(extra_nonce.data() + 1);
     return true;
   }

Here is the caller graph for this function:

◆ get_protocol_state_char()

char cryptonote::get_protocol_state_char ( cryptonote_connection_context::state s )

inline

Definition at line 91 of file connection_context.h.

   {
     switch (s)
     {
     case cryptonote_connection_context::state_before_handshake:
       return 'h';
     case cryptonote_connection_context::state_synchronizing:
       return 's';
     case cryptonote_connection_context::state_standby:
       return 'w';
     case cryptonote_connection_context::state_idle:
       return 'i';
     case cryptonote_connection_context::state_normal:
       return 'n';
     default:
       return 'u';
     }
   }

◆ get_protocol_state_string()

std::string cryptonote::get_protocol_state_string ( cryptonote_connection_context::state s )

inline

Definition at line 72 of file connection_context.h.

   {
     switch (s)
     {
     case cryptonote_connection_context::state_before_handshake:
       return "before_handshake";
     case cryptonote_connection_context::state_synchronizing:
       return "synchronizing";
     case cryptonote_connection_context::state_standby:
       return "standby";
     case cryptonote_connection_context::state_idle:
       return "idle";
     case cryptonote_connection_context::state_normal:
       return "normal";
     default:
       return "unknown";
     }    
   }

◆ get_pruned_transaction_hash()

crypto::hash cryptonote::get_pruned_transaction_hash	(	const transaction &	t,
		const crypto::hash &	pruned_data_hash
	)

Definition at line 1007 of file cryptonote_format_utils.cpp.

   {
     // v1 transactions hash the entire blob
     CHECK_AND_ASSERT_THROW_MES(t.version > 1, "Hash for pruned v1 tx cannot be calculated");
  
     // v2 transactions hash different parts together, than hash the set of those hashes
     crypto::hash hashes[3];
  
     // prefix
     get_transaction_prefix_hash(t, hashes[0]);
  
     transaction &tt = const_cast<transaction&>(t);
  
     // base rct
     {
       std::stringstream ss;
       binary_archive<true> ba(ss);
       const size_t inputs = t.vin.size();
       const size_t outputs = t.vout.size();
       bool r = tt.rct_signatures.serialize_rctsig_base(ba, inputs, outputs);
       CHECK_AND_ASSERT_THROW_MES(r, "Failed to serialize rct signatures base");
       cryptonote::get_blob_hash(ss.str(), hashes[1]);
     }
  
     // prunable rct
     if (t.rct_signatures.type == rct::RCTTypeNull)
       hashes[2] = crypto::null_hash;
     else
       hashes[2] = pruned_data_hash;
  
     // the tx hash is the hash of the 3 hashes
     crypto::hash res = cn_fast_hash(hashes, sizeof(hashes));
     return res;
   }

Here is the call graph for this function:

◆ get_transaction_hash() [1/4]

crypto::hash cryptonote::get_transaction_hash ( const transaction & t )

Definition at line 962 of file cryptonote_format_utils.cpp.

   {
     crypto::hash h = null_hash;
     get_transaction_hash(t, h, NULL);
     CHECK_AND_ASSERT_THROW_MES(get_transaction_hash(t, h, NULL), "Failed to calculate transaction hash");
     return h;
   }

Here is the caller graph for this function:

◆ get_transaction_hash() [2/4]

bool cryptonote::get_transaction_hash	(	const transaction &	t,
		crypto::hash &	res
	)

Definition at line 970 of file cryptonote_format_utils.cpp.

   {
     return get_transaction_hash(t, res, NULL);
   }

Here is the call graph for this function:

◆ get_transaction_hash() [3/4]

bool cryptonote::get_transaction_hash	(	const transaction &	t,
		crypto::hash &	res,
		size_t &	blob_size
	)

Definition at line 1126 of file cryptonote_format_utils.cpp.

   {
     return get_transaction_hash(t, res, &blob_size);
   }

Here is the caller graph for this function:

◆ get_transaction_hash() [4/4]

bool cryptonote::get_transaction_hash	(	const transaction &	t,
		crypto::hash &	res,
		size_t *	blob_size
	)

Definition at line 1092 of file cryptonote_format_utils.cpp.

   {
     if (t.is_hash_valid())
     {
 #ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
       CHECK_AND_ASSERT_THROW_MES(!calculate_transaction_hash(t, res, blob_size) || t.hash == res, "tx hash cash integrity failure");
 #endif
       res = t.hash;
       if (blob_size)
       {
         if (!t.is_blob_size_valid())
         {
           t.blob_size = get_object_blobsize(t);
           t.set_blob_size_valid(true);
         }
         *blob_size = t.blob_size;
       }
       ++tx_hashes_cached_count;
       return true;
     }
     ++tx_hashes_calculated_count;
     bool ret = calculate_transaction_hash(t, res, blob_size);
     if (!ret)
       return false;
     t.hash = res;
     t.set_hash_valid(true);
     if (blob_size)
     {
       t.blob_size = *blob_size;
       t.set_blob_size_valid(true);
     }
     return true;
   }

Here is the call graph for this function:

◆ get_transaction_prefix_hash() [1/2]

crypto::hash cryptonote::get_transaction_prefix_hash ( const transaction_prefix & tx )

Definition at line 121 of file cryptonote_format_utils.cpp.

   {
     crypto::hash h = null_hash;
     get_transaction_prefix_hash(tx, h);
     return h;
   }

Here is the caller graph for this function:

◆ get_transaction_prefix_hash() [2/2]

void cryptonote::get_transaction_prefix_hash	(	const transaction_prefix &	tx,
		crypto::hash &	h
	)

Definition at line 112 of file cryptonote_format_utils.cpp.

   {
     std::ostringstream s;
     binary_archive<true> a(s);
     ::serialization::serialize(a, const_cast<transaction_prefix&>(tx));
  
     crypto::cn_fast_hash(s.str().data(), s.str().size(), h);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_transaction_prunable_hash()

crypto::hash cryptonote::get_transaction_prunable_hash	(	const transaction &	t,
		const cryptonote::blobdata *	blobdata
	)

Definition at line 1000 of file cryptonote_format_utils.cpp.

   {
     crypto::hash res;
     CHECK_AND_ASSERT_THROW_MES(calculate_transaction_prunable_hash(t, blobdata, res), "Failed to calculate tx prunable hash");
     return res;
   }

Here is the call graph for this function:

◆ get_transaction_weight() [1/2]

uint64_t cryptonote::get_transaction_weight ( const transaction & tx )

Definition at line 352 of file cryptonote_format_utils.cpp.

   {
     size_t blob_size;
     if (tx.is_blob_size_valid())
     {
       blob_size = tx.blob_size;
     }
     else
     {
       std::ostringstream s;
       binary_archive<true> a(s);
       ::serialization::serialize(a, const_cast<transaction&>(tx));
       blob_size = s.str().size();
     }
     return get_transaction_weight(tx, blob_size);
   }

Here is the call graph for this function:

◆ get_transaction_weight() [2/2]

uint64_t cryptonote::get_transaction_weight	(	const transaction &	tx,
		size_t	blob_size
	)

Definition at line 347 of file cryptonote_format_utils.cpp.

   {
     return blob_size;
   }

Here is the caller graph for this function:

◆ get_tx_fee() [1/2]

uint64_t cryptonote::get_tx_fee ( const transaction & tx )

Definition at line 394 of file cryptonote_format_utils.cpp.

   {
     uint64_t r = 0;
     if(!get_tx_fee(tx, r))
       return 0;
     return r;
   }

◆ get_tx_fee() [2/2]

bool cryptonote::get_tx_fee	(	const transaction &	tx,
		uint64_t &	fee
	)

Definition at line 369 of file cryptonote_format_utils.cpp.

   {
     uint64_t amount_in = 0;
     uint64_t amount_out = 0;
     for(auto& in: tx.vin)
     {
       CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key) || in.type() == typeid(txin_to_key_public), 0, "unexpected type id in transaction");
  
       if(tx.version == 1 || tx.version == 2)
       {
         amount_in += boost::get<txin_to_key>(in).amount;
       }
       else
       {
         amount_in += boost::get<txin_to_key_public>(in).amount;
       }
     }
     for(auto& o: tx.vout)
       amount_out += o.amount;
  
     CHECK_AND_ASSERT_MES(amount_in >= amount_out, false, "transaction spend (" <<amount_in << ") more than it has (" << amount_out << ")");
     fee = amount_in - amount_out;
     return true;
   }

Here is the caller graph for this function:

◆ get_tx_pub_key_from_extra() [1/3]

crypto::public_key cryptonote::get_tx_pub_key_from_extra	(	const std::vector< uint8_t > &	tx_extra,
		size_t	pk_index
	)

Definition at line 515 of file cryptonote_format_utils.cpp.

   {
     std::vector<tx_extra_field> tx_extra_fields;
     parse_tx_extra(tx_extra, tx_extra_fields);
  
     tx_extra_pub_key pub_key_field;
     if(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, pk_index))
       return null_pkey;
  
     return pub_key_field.pub_key;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_tx_pub_key_from_extra() [2/3]

crypto::public_key cryptonote::get_tx_pub_key_from_extra	(	const transaction &	tx,
		size_t	pk_index
	)

Definition at line 532 of file cryptonote_format_utils.cpp.

   {
     return get_tx_pub_key_from_extra(tx.extra, pk_index);
   }

Here is the caller graph for this function:

◆ get_tx_pub_key_from_extra() [3/3]

crypto::public_key cryptonote::get_tx_pub_key_from_extra	(	const transaction_prefix &	tx_prefix,
		size_t	pk_index
	)

Definition at line 527 of file cryptonote_format_utils.cpp.

   {
     return get_tx_pub_key_from_extra(tx_prefix.extra, pk_index);
   }

Here is the call graph for this function:

◆ get_tx_tree_hash() [1/3]

crypto::hash cryptonote::get_tx_tree_hash ( const block & b )

Definition at line 1268 of file cryptonote_format_utils.cpp.

   {
     std::vector<crypto::hash> txs_ids;
     txs_ids.reserve(1 + b.tx_hashes.size());
     crypto::hash h = null_hash;
     size_t bl_sz = 0;
     CHECK_AND_ASSERT_THROW_MES(get_transaction_hash(b.miner_tx, h, bl_sz), "Failed to calculate transaction hash");
     txs_ids.push_back(h);
     for(auto& th: b.tx_hashes)
       txs_ids.push_back(th);
     return get_tx_tree_hash(txs_ids);
   }

Here is the caller graph for this function:

◆ get_tx_tree_hash() [2/3]

crypto::hash cryptonote::get_tx_tree_hash ( const std::vector< crypto::hash > & tx_hashes )

Definition at line 1261 of file cryptonote_format_utils.cpp.

   {
     crypto::hash h = null_hash;
     get_tx_tree_hash(tx_hashes, h);
     return h;
   }

◆ get_tx_tree_hash() [3/3]

void cryptonote::get_tx_tree_hash	(	const std::vector< crypto::hash > &	tx_hashes,
		crypto::hash &	h
	)

Definition at line 1256 of file cryptonote_format_utils.cpp.

   {
     tree_hash(tx_hashes.data(), tx_hashes.size(), h);
   }

Here is the call graph for this function:

◆ get_unit()

std::string cryptonote::get_unit ( unsigned int decimal_point )

Definition at line 919 of file cryptonote_format_utils.cpp.

   {
     if (decimal_point == (unsigned int)-1)
       decimal_point = default_decimal_point;
     switch (decimal_point)
     {
       case 2:
         return "electroneum";
     case 0:
         return "ecent";
       default:
         ASSERT_MES_AND_THROW("Invalid decimal point specification: " << decimal_point);
     }
   }

◆ getpos() [1/2]

template<>

unsigned int cryptonote::getpos ( binary_archive< false > & ar )

inline

Definition at line 237 of file cryptonote_basic.h.

237 { return ar.stream().tellg(); }

binary_archive_base::stream

stream_type & stream()

Definition: binary_archive.h:77

Here is the call graph for this function:

◆ getpos() [2/2]

template<>

unsigned int cryptonote::getpos ( binary_archive< true > & ar )

inline

Definition at line 236 of file cryptonote_basic.h.

236 { return ar.stream().tellp(); }

Here is the call graph for this function:

◆ hex()

std::string cryptonote::hex ( difficulty_type v )

Definition at line 254 of file difficulty.cpp.

   {
     static const char chars[] = "0123456789abcdef";
     std::string s;
     while (v > 0)
     {
       s.push_back(chars[(v & 0xf).convert_to<unsigned>()]);
       v >>= 4;
     }
     if (s.empty())
       s += "0";
     std::reverse(s.begin(), s.end());
     return "0x" + s;
   }

◆ is_coinbase()

bool cryptonote::is_coinbase ( const transaction & tx )

Definition at line 232 of file cryptonote_basic_impl.cpp.

   {
     if(tx.vin.size() != 1)
       return false;
  
     if(tx.vin[0].type() != typeid(txin_gen))
       return false;
  
     return true;
   }

Here is the caller graph for this function:

◆ is_out_to_acc()

bool cryptonote::is_out_to_acc	(	const account_keys &	acc,
		const txout_to_key &	out_key,
		const crypto::public_key &	tx_pub_key,
		const std::vector< crypto::public_key > &	additional_tx_pub_keys,
		size_t	output_index
	)

Definition at line 812 of file cryptonote_format_utils.cpp.

   {
     crypto::key_derivation derivation;
     bool r = acc.get_device().generate_key_derivation(tx_pub_key, acc.m_view_secret_key, derivation);
     CHECK_AND_ASSERT_MES(r, false, "Failed to generate key derivation");
     crypto::public_key pk;
     r = acc.get_device().derive_public_key(derivation, output_index, acc.m_account_address.m_spend_public_key, pk);
     CHECK_AND_ASSERT_MES(r, false, "Failed to derive public key");
     if (pk == out_key.key)
       return true;
     // try additional tx pubkeys if available
     if (!additional_tx_pub_keys.empty())
     {
       CHECK_AND_ASSERT_MES(output_index < additional_tx_pub_keys.size(), false, "wrong number of additional tx pubkeys");
       r = acc.get_device().generate_key_derivation(additional_tx_pub_keys[output_index], acc.m_view_secret_key, derivation);
       CHECK_AND_ASSERT_MES(r, false, "Failed to generate key derivation");
       r = acc.get_device().derive_public_key(derivation, output_index, acc.m_account_address.m_spend_public_key, pk);
       CHECK_AND_ASSERT_MES(r, false, "Failed to derive public key");
       return pk == out_key.key;
     }
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_out_to_acc_precomp()

boost::optional< subaddress_receive_info > cryptonote::is_out_to_acc_precomp	(	const std::unordered_map< crypto::public_key, subaddress_index > &	subaddresses,
		const crypto::public_key &	out_key,
		const crypto::key_derivation &	derivation,
		const std::vector< crypto::key_derivation > &	additional_derivations,
		size_t	output_index,
		hw::device &	hwdev
	)

Definition at line 835 of file cryptonote_format_utils.cpp.

   {
     // try the shared tx pubkey
     crypto::public_key subaddress_spendkey;
     hwdev.derive_subaddress_public_key(out_key, derivation, output_index, subaddress_spendkey);
     auto found = subaddresses.find(subaddress_spendkey);
     if (found != subaddresses.end())
       return subaddress_receive_info{ found->second, derivation };
     // try additional tx pubkeys if available
     if (!additional_derivations.empty())
     {
       CHECK_AND_ASSERT_MES(output_index < additional_derivations.size(), boost::none, "wrong number of additional derivations");
       hwdev.derive_subaddress_public_key(out_key, additional_derivations[output_index], output_index, subaddress_spendkey);
       found = subaddresses.find(subaddress_spendkey);
       if (found != subaddresses.end())
         return subaddress_receive_info{ found->second, additional_derivations[output_index] };
     }
     return boost::none;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_out_to_acc_precomp_public()

boost::optional< subaddress_receive_info > cryptonote::is_out_to_acc_precomp_public	(	const std::unordered_map< crypto::public_key, subaddress_index > &	subaddresses,
		const cryptonote::account_public_address	output_address
	)

Definition at line 855 of file cryptonote_format_utils.cpp.

   {
       crypto::public_key subaddress_spendkey = output_address.m_spend_public_key;
       auto found = subaddresses.find(subaddress_spendkey);
       if (found != subaddresses.end()){
            return subaddress_receive_info{found->second, {}};
       }
       return boost::none;
   }

◆ is_v1_tx() [1/2]

bool cryptonote::is_v1_tx ( const blobdata & tx_blob )

Definition at line 203 of file cryptonote_format_utils.cpp.

   {
     return is_v1_tx(blobdata_ref{tx_blob.data(), tx_blob.size()});
   }

Here is the call graph for this function:

◆ is_v1_tx() [2/2]

bool cryptonote::is_v1_tx ( const blobdata_ref & tx_blob )

Definition at line 190 of file cryptonote_format_utils.cpp.

   {
     //TODO: Public - assure return true. Build logic for prunable v2/v3 tx data later.
     return true;
  
     uint64_t version;
     const char* begin = static_cast<const char*>(tx_blob.data());
     const char* end = begin + tx_blob.size();
     int read = tools::read_varint(begin, end, version);
     if (read <= 0)
       throw std::runtime_error("Internal error getting transaction version");
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_valid_decomposed_amount()

bool cryptonote::is_valid_decomposed_amount ( uint64_t amount )

Definition at line 1281 of file cryptonote_format_utils.cpp.

   {
     const uint64_t *begin = valid_decomposed_outputs;
     const uint64_t *end = valid_decomposed_outputs + sizeof(valid_decomposed_outputs) / sizeof(valid_decomposed_outputs[0]);
     return std::binary_search(begin, end, amount);
   }

Here is the caller graph for this function:

◆ lmdb_resized()

void cryptonote::lmdb_resized ( MDB_env * env )

Definition at line 495 of file db_lmdb.cpp.

 {
   mdb_txn_safe::prevent_new_txns();
  
   MGINFO("LMDB map resize detected.");
  
   MDB_envinfo mei;
  
   mdb_env_info(env, &mei);
   uint64_t old = mei.me_mapsize;
  
   mdb_txn_safe::wait_no_active_txns();
  
   int result = mdb_env_set_mapsize(env, 0);
   if (result)
     throw0(DB_ERROR(lmdb_error("Failed to set new mapsize: ", result).c_str()));
  
   mdb_env_info(env, &mei);
   uint64_t new_mapsize = mei.me_mapsize;
  
   MGINFO("LMDB Mapsize increased." << "  Old: " << old / (1024 * 1024) << "MiB" << ", New: " << new_mapsize / (1024 * 1024) << "MiB");
  
   mdb_txn_safe::allow_new_txns();
 }

Here is the caller graph for this function:

◆ lmdb_txn_begin()

int cryptonote::lmdb_txn_begin	(	MDB_env *	env,
		MDB_txn *	parent,
		unsigned int	flags,
		MDB_txn **	txn
	)

inline

Definition at line 520 of file db_lmdb.cpp.

 {
   int res = mdb_txn_begin(env, parent, flags, txn);
   if (res == MDB_MAP_RESIZED) {
     lmdb_resized(env);
     res = mdb_txn_begin(env, parent, flags, txn);
   }
   return res;
 }

Here is the caller graph for this function:

◆ lmdb_txn_renew()

int cryptonote::lmdb_txn_renew ( MDB_txn * txn )

inline

Definition at line 530 of file db_lmdb.cpp.

 {
   int res = mdb_txn_renew(txn);
   if (res == MDB_MAP_RESIZED) {
     lmdb_resized(mdb_txn_env(txn));
     res = mdb_txn_renew(txn);
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookup_acc_outs() [1/2]

bool cryptonote::lookup_acc_outs	(	const account_keys &	acc,
		const transaction &	tx,
		const crypto::public_key &	tx_pub_key,
		const std::vector< crypto::public_key > &	additional_tx_pub_keys,
		std::vector< size_t > &	outs,
		uint64_t &	etn_transfered
	)

Definition at line 874 of file cryptonote_format_utils.cpp.

   {
     CHECK_AND_ASSERT_MES(additional_tx_pub_keys.empty() || additional_tx_pub_keys.size() == tx.vout.size(), false, "wrong number of additional pubkeys" );
     etn_transfered = 0;
     size_t i = 0;
     for(const tx_out& o:  tx.vout)
     {
       CHECK_AND_ASSERT_MES(o.target.type() ==  typeid(txout_to_key), false, "wrong type id in transaction out" );
       if(is_out_to_acc(acc, boost::get<txout_to_key>(o.target), tx_pub_key, additional_tx_pub_keys, i))
       {
         outs.push_back(i);
         etn_transfered += o.amount;
       }
       i++;
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookup_acc_outs() [2/2]

bool cryptonote::lookup_acc_outs	(	const account_keys &	acc,
		const transaction &	tx,
		std::vector< size_t > &	outs,
		uint64_t &	etn_transfered
	)

Definition at line 865 of file cryptonote_format_utils.cpp.

   {
     crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
     if(null_pkey == tx_pub_key)
       return false;
     std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
     return lookup_acc_outs(acc, tx, tx_pub_key, additional_tx_pub_keys, outs, etn_transfered);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ max128bit()

const boost::multiprecision::uint256_t cryptonote::max128bit ( std::numeric_limits< boost::multiprecision::uint128_t > ::max() )

Here is the caller graph for this function:

◆ max256bit()

const boost::multiprecision::uint512_t cryptonote::max256bit ( std::numeric_limits< boost::multiprecision::uint256_t > ::max() )

Here is the caller graph for this function:

◆ max64bit()

const difficulty_type cryptonote::max64bit ( std::numeric_limits< std::uint64_t > ::max() )

Here is the caller graph for this function:

◆ multisig_rounds_required()

uint32_t cryptonote::multisig_rounds_required	(	uint32_t	participants,
		uint32_t	threshold
	)

Definition at line 181 of file multisig.cpp.

   {
     CHECK_AND_ASSERT_THROW_MES(participants >= threshold, "participants must be greater or equal than threshold");
     return participants - threshold + 1;
   }

◆ new_db()

BlockchainDB * cryptonote::new_db ( const std::string & db_type )

Definition at line 100 of file blockchain_db.cpp.

 {
   if (db_type == "lmdb")
     return new BlockchainLMDB();
 #if defined(BERKELEY_DB)
   if (db_type == "berkeley")
     return new BlockchainBDB();
 #endif
   return NULL;
 }

Here is the caller graph for this function:

◆ next_difficulty() [1/2]

difficulty_type cryptonote::next_difficulty	(	std::vector< std::uint64_t >	timestamps,
		std::vector< difficulty_type >	cumulative_difficulties,
		size_t	target_seconds,
		uint8_t	version = `1`
	)

◆ next_difficulty() [2/2]

difficulty_type cryptonote::next_difficulty	(	std::vector< uint64_t >	timestamps,
		std::vector< difficulty_type >	cumulative_difficulties,
		size_t	target_seconds,
		uint8_t	version
	)

Definition at line 210 of file difficulty.cpp.

                                                                                                                                                               {
     
     const size_t difficultyWindow = version == 6 ? DIFFICULTY_WINDOW_V6 : DIFFICULTY_WINDOW;
     
     //cutoff DIFFICULTY_LAG
     if(timestamps.size() > difficultyWindow)
     {
       timestamps.resize(difficultyWindow);
       cumulative_difficulties.resize(difficultyWindow);
     }
  
  
     size_t length = timestamps.size();
     assert(length == cumulative_difficulties.size());
     if (length <= 1) {
       return 1;
     }
     static_assert(DIFFICULTY_WINDOW >= 2, "Window is too small");
     static_assert(DIFFICULTY_WINDOW_V6 >= 2, "Window is too small");
     assert(length <= difficultyWindow);
     sort(timestamps.begin(), timestamps.end());
     size_t cut_begin, cut_end;
     static_assert(2 * DIFFICULTY_CUT <= DIFFICULTY_WINDOW - 2, "Cut length is too large");
     static_assert(2 * DIFFICULTY_CUT <= DIFFICULTY_WINDOW_V6 - 2, "Cut length is too large");
     if (length <= difficultyWindow - 2 * DIFFICULTY_CUT) {
       cut_begin = 0;
       cut_end = length;
     } else {
       cut_begin = (length - (difficultyWindow - 2 * DIFFICULTY_CUT) + 1) / 2;
       cut_end = cut_begin + (difficultyWindow - 2 * DIFFICULTY_CUT);
     }
     assert(/*cut_begin >= 0 &&*/ cut_begin + 2 <= cut_end && cut_end <= length);
     uint64_t time_span = timestamps[cut_end - 1] - timestamps[cut_begin];
     if (time_span == 0) {
       time_span = 1;
     }
     difficulty_type total_work = cumulative_difficulties[cut_end - 1] - cumulative_difficulties[cut_begin];
     assert(total_work > 0);
     boost::multiprecision::uint256_t res =  (boost::multiprecision::uint256_t(total_work) * target_seconds + time_span - 1) / time_span;
     if(res > max128bit)
       return 0; // to behave like previous implementation, may be better return max128bit?
     return res.convert_to<difficulty_type>();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_difficulty_64()

uint64_t cryptonote::next_difficulty_64	(	std::vector< std::uint64_t >	timestamps,
		std::vector< uint64_t >	cumulative_difficulties,
		size_t	target_seconds,
		uint8_t	version
	)

Definition at line 123 of file difficulty.cpp.

                                                                                                                                                       {
  
     const size_t difficultyWindow = version == 6 ? DIFFICULTY_WINDOW_V6 : DIFFICULTY_WINDOW;
  
     if(timestamps.size() > difficultyWindow)
     {
       timestamps.resize(difficultyWindow);
       cumulative_difficulties.resize(difficultyWindow);
     }
  
     size_t length = timestamps.size();
     assert(length == cumulative_difficulties.size());
     if (length <= 1) {
       return 1;
     }
  
     static_assert(DIFFICULTY_WINDOW >= 2, "Window is too small");
     static_assert(DIFFICULTY_WINDOW_V6 >= 2, "Window is too small");
     assert(length <= difficultyWindow);
     sort(timestamps.begin(), timestamps.end());
     size_t cut_begin, cut_end;
  
     static_assert(2 * DIFFICULTY_CUT <= DIFFICULTY_WINDOW - 2, "Cut length is too large");
     static_assert(2 * DIFFICULTY_CUT <= DIFFICULTY_WINDOW_V6 - 2, "Cut length is too large");
  
     if (length <= difficultyWindow - 2 * DIFFICULTY_CUT) {
       cut_begin = 0;
       cut_end = length;
     } else {
       cut_begin = (length - (difficultyWindow - 2 * DIFFICULTY_CUT) + 1) / 2;
       cut_end = cut_begin + (difficultyWindow - 2 * DIFFICULTY_CUT);
     }
     assert(/*cut_begin >= 0 &&*/ cut_begin + 2 <= cut_end && cut_end <= length);
     uint64_t time_span = timestamps[cut_end - 1] - timestamps[cut_begin];
     if (time_span == 0) {
       time_span = 1;
     }
     uint64_t total_work = cumulative_difficulties[cut_end - 1] - cumulative_difficulties[cut_begin];
     assert(total_work > 0);
     uint64_t low, high;
     mul(total_work, target_seconds, low, high);
     // blockchain errors "difficulty overhead" if this function returns zero.
     // TODO: consider throwing an exception instead
     if (high != 0 || low + time_span - 1 < low) {
       return 0;
     }
     return (low + time_span - 1) / time_span;
   }

◆ obj_to_json_str()

template<typename T >

std::string cryptonote::obj_to_json_str ( T & obj )

Definition at line 198 of file cryptonote_format_utils.h.

   {
     std::stringstream ss;
     json_archive<true> ar(ss, true);
     bool r = ::serialization::serialize(ar, obj);
     CHECK_AND_ASSERT_MES(r, "", "obj_to_json_str failed: serialization::serialize returned false");
     return ss.str();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<()

std::ostream& cryptonote::operator<<	(	std::ostream &	out,
		const cryptonote::subaddress_index &	subaddr_index
	)

inline

Definition at line 59 of file subaddress_index.h.

   {
     return out << subaddr_index.major << '/' << subaddr_index.minor;
   }

◆ operator==() [1/2]

bool cryptonote::operator==	(	const cryptonote::block &	a,
		const cryptonote::block &	b
	)

Definition at line 367 of file cryptonote_basic_impl.cpp.

                                                                        {
     return cryptonote::get_block_hash(a) == cryptonote::get_block_hash(b);
   }

Here is the call graph for this function:

◆ operator==() [2/2]

bool cryptonote::operator==	(	const cryptonote::transaction &	a,
		const cryptonote::transaction &	b
	)

Definition at line 363 of file cryptonote_basic_impl.cpp.

                                                                                    {
     return cryptonote::get_transaction_hash(a) == cryptonote::get_transaction_hash(b);
   }

Here is the call graph for this function:

◆ parse_amount()

bool cryptonote::parse_amount	(	uint64_t &	amount,
		const std::string &	str_amount_
	)

Definition at line 312 of file cryptonote_format_utils.cpp.

   {
     std::string str_amount = str_amount_;
     boost::algorithm::trim(str_amount);
  
     size_t point_index = str_amount.find_first_of('.');
     size_t fraction_size;
     if (std::string::npos != point_index)
     {
       fraction_size = str_amount.size() - point_index - 1;
       while (default_decimal_point < fraction_size && '0' == str_amount.back())
       {
         str_amount.erase(str_amount.size() - 1, 1);
         --fraction_size;
       }
       if (default_decimal_point < fraction_size)
         return false;
       str_amount.erase(point_index, 1);
     }
     else
     {
       fraction_size = 0;
     }
  
     if (str_amount.empty())
       return false;
  
     if (fraction_size < default_decimal_point)
     {
       str_amount.append(default_decimal_point - fraction_size, '0');
     }
  
     return string_tools::get_xtype_from_string(amount, str_amount);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_and_validate_block_from_blob() [1/3]

bool cryptonote::parse_and_validate_block_from_blob	(	const blobdata &	b_blob,
		block &	b
	)

Definition at line 1226 of file cryptonote_format_utils.cpp.

   {
     return parse_and_validate_block_from_blob(b_blob, b, NULL);
   }

Here is the call graph for this function:

◆ parse_and_validate_block_from_blob() [2/3]

bool cryptonote::parse_and_validate_block_from_blob	(	const blobdata &	b_blob,
		block &	b,
		crypto::hash &	block_hash
	)

Definition at line 1231 of file cryptonote_format_utils.cpp.

   {
     return parse_and_validate_block_from_blob(b_blob, b, &block_hash);
   }

Here is the caller graph for this function:

◆ parse_and_validate_block_from_blob() [3/3]

bool cryptonote::parse_and_validate_block_from_blob	(	const blobdata &	b_blob,
		block &	b,
		crypto::hash *	block_hash
	)

Definition at line 1207 of file cryptonote_format_utils.cpp.

   {
     std::stringstream ss;
     ss << b_blob;
     binary_archive<false> ba(ss);
     bool r = ::serialization::serialize(ba, b);
     CHECK_AND_ASSERT_MES(r, false, "Failed to parse block from blob");
     b.invalidate_hashes();
     b.miner_tx.invalidate_hashes();
     if (block_hash)
     {
       calculate_block_hash(b, *block_hash, &b_blob);
       ++block_hashes_calculated_count;
       b.hash = *block_hash;
       b.set_hash_valid(true);
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_and_validate_tx_base_from_blob()

bool cryptonote::parse_and_validate_tx_base_from_blob	(	const blobdata &	tx_blob,
		transaction &	tx
	)

Definition at line 146 of file cryptonote_format_utils.cpp.

   {
     std::stringstream ss;
     ss << tx_blob;
     binary_archive<false> ba(ss);
     bool r = tx.serialize_base(ba);
     CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
     CHECK_AND_ASSERT_MES(expand_transaction_1(tx, true), false, "Failed to expand transaction data");
     tx.invalidate_hashes();
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_and_validate_tx_from_blob() [1/3]

bool cryptonote::parse_and_validate_tx_from_blob	(	const blobdata &	tx_blob,
		transaction &	tx
	)

Definition at line 133 of file cryptonote_format_utils.cpp.

   {
     std::stringstream ss;
     ss << tx_blob;
     binary_archive<false> ba(ss);
     bool r = ::serialization::serialize(ba, tx);
     CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
     CHECK_AND_ASSERT_MES(expand_transaction_1(tx, false), false, "Failed to expand transaction data");
     tx.invalidate_hashes();
     tx.set_blob_size(tx_blob.size());
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_and_validate_tx_from_blob() [2/3]

bool cryptonote::parse_and_validate_tx_from_blob	(	const blobdata &	tx_blob,
		transaction &	tx,
		crypto::hash &	tx_hash
	)

Definition at line 168 of file cryptonote_format_utils.cpp.

   {
     std::stringstream ss;
     ss << tx_blob;
     binary_archive<false> ba(ss);
     bool r = ::serialization::serialize(ba, tx);
     CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
     CHECK_AND_ASSERT_MES(expand_transaction_1(tx, false), false, "Failed to expand transaction data");
     tx.invalidate_hashes();
     //TODO: validate tx
  
     return get_transaction_hash(tx, tx_hash);
   }

Here is the call graph for this function:

◆ parse_and_validate_tx_from_blob() [3/3]

bool cryptonote::parse_and_validate_tx_from_blob	(	const blobdata &	tx_blob,
		transaction &	tx,
		crypto::hash &	tx_hash,
		crypto::hash &	tx_prefix_hash
	)

Definition at line 182 of file cryptonote_format_utils.cpp.

   {
     if (!parse_and_validate_tx_from_blob(tx_blob, tx, tx_hash))
       return false;
     get_transaction_prefix_hash(tx, tx_prefix_hash);
     return true;
   }

Here is the call graph for this function:

◆ parse_and_validate_tx_prefix_from_blob()

bool cryptonote::parse_and_validate_tx_prefix_from_blob	(	const blobdata &	tx_blob,
		transaction_prefix &	tx
	)

Definition at line 158 of file cryptonote_format_utils.cpp.

   {
     std::stringstream ss;
     ss << tx_blob;
     binary_archive<false> ba(ss);
     bool r = ::serialization::serialize_noeof(ba, tx);
     CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction prefix from blob");
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_tx_extra()

bool cryptonote::parse_tx_extra	(	const std::vector< uint8_t > &	tx_extra,
		std::vector< tx_extra_field > &	tx_extra_fields
	)

Definition at line 402 of file cryptonote_format_utils.cpp.

   {
     tx_extra_fields.clear();
  
     if(tx_extra.empty())
       return true;
  
     std::string extra_str(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size());
     std::istringstream iss(extra_str);
     binary_archive<false> ar(iss);
  
     bool eof = false;
     while (!eof)
     {
       tx_extra_field field;
       bool r = ::do_serialize(ar, field);
       CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
       tx_extra_fields.push_back(field);
  
       std::ios_base::iostate state = iss.rdstate();
       eof = (EOF == iss.peek());
       iss.clear(state);
     }
     CHECK_AND_NO_ASSERT_MES_L1(::serialization::check_stream_state(ar), false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
  
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ power_integral()

uint64_t cryptonote::power_integral	(	uint64_t	a,
		uint64_t	b
	)

Definition at line 302 of file cryptonote_format_utils.cpp.

   {
     if(b == 0)
       return 1;
     uint64_t total = a;
     for(uint64_t i = 1; i != b; i++)
       total *= a;
     return total;
   }

◆ print_etn()

std::string cryptonote::print_etn	(	uint64_t	amount,
		unsigned int	decimal_point
	)

Definition at line 934 of file cryptonote_format_utils.cpp.

   {
     if (decimal_point == (unsigned int)-1)
       decimal_point = default_decimal_point;
     std::string s = std::to_string(amount);
     if(s.size() < decimal_point+1)
     {
       s.insert(0, decimal_point+1 - s.size(), '0');
     }
     if (decimal_point > 0)
       s.insert(s.size() - decimal_point, ".");
     return s;
   }

Here is the caller graph for this function:

◆ relative_output_offsets_to_absolute()

std::vector< uint64_t > cryptonote::relative_output_offsets_to_absolute ( const std::vector< uint64_t > & off )

Definition at line 1180 of file cryptonote_format_utils.cpp.

   {
     std::vector<uint64_t> res = off;
     for(size_t i = 1; i < res.size(); i++)
       res[i] += res[i-1];
     return res;
   }

Here is the caller graph for this function:

◆ remove_field_from_tx_extra()

bool cryptonote::remove_field_from_tx_extra	(	std::vector< uint8_t > &	tx_extra,
		const std::type_info &	type
	)

Definition at line 605 of file cryptonote_format_utils.cpp.

   {
     if (tx_extra.empty())
       return true;
     std::string extra_str(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size());
     std::istringstream iss(extra_str);
     binary_archive<false> ar(iss);
     std::ostringstream oss;
     binary_archive<true> newar(oss);
  
     bool eof = false;
     while (!eof)
     {
       tx_extra_field field;
       bool r = ::do_serialize(ar, field);
       CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
       if (field.type() != type)
         ::do_serialize(newar, field);
  
       std::ios_base::iostate state = iss.rdstate();
       eof = (EOF == iss.peek());
       iss.clear(state);
     }
     CHECK_AND_NO_ASSERT_MES_L1(::serialization::check_stream_state(ar), false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
     tx_extra.clear();
     std::string s = oss.str();
     tx_extra.reserve(s.size());
     std::copy(s.begin(), s.end(), std::back_inserter(tx_extra));
     return true;
   }

Here is the call graph for this function:

◆ set_default_decimal_point()

void cryptonote::set_default_decimal_point ( unsigned int decimal_point )

Definition at line 902 of file cryptonote_format_utils.cpp.

   {
     switch (decimal_point)
     {
       case 2:
         default_decimal_point = decimal_point;
         break;
       default:
         ASSERT_MES_AND_THROW("Invalid decimal point specification: " << decimal_point);
     }
   }

◆ set_encrypted_payment_id_to_tx_extra_nonce()

void cryptonote::set_encrypted_payment_id_to_tx_extra_nonce	(	blobdata &	extra_nonce,
		const crypto::hash8 &	payment_id
	)

Definition at line 644 of file cryptonote_format_utils.cpp.

   {
     extra_nonce.clear();
     extra_nonce.push_back(TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID);
     const uint8_t* payment_id_ptr = reinterpret_cast<const uint8_t*>(&payment_id);
     std::copy(payment_id_ptr, payment_id_ptr + sizeof(payment_id), std::back_inserter(extra_nonce));
   }

Here is the call graph for this function:

◆ set_payment_id_to_tx_extra_nonce()

void cryptonote::set_payment_id_to_tx_extra_nonce	(	blobdata &	extra_nonce,
		const crypto::hash &	payment_id
	)

Definition at line 636 of file cryptonote_format_utils.cpp.

   {
     extra_nonce.clear();
     extra_nonce.push_back(TX_EXTRA_NONCE_PAYMENT_ID);
     const uint8_t* payment_id_ptr = reinterpret_cast<const uint8_t*>(&payment_id);
     std::copy(payment_id_ptr, payment_id_ptr + sizeof(payment_id), std::back_inserter(extra_nonce));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ short_hash_str()

std::string cryptonote::short_hash_str ( const crypto::hash & h )

Definition at line 803 of file cryptonote_format_utils.cpp.

   {
     std::string res = string_tools::pod_to_hex(h);
     CHECK_AND_ASSERT_MES(res.size() == 64, res, "wrong hash256 with string_tools::pod_to_hex conversion");
     auto erased_pos = res.erase(8, 48);
     res.insert(8, "....");
     return res;
   }

Here is the call graph for this function:

◆ slow_memmem()

size_t cryptonote::slow_memmem	(	const void *	start_buff,
		size_t	buflen,
		const void *	pat,
		size_t	patlen
	)

Definition at line 1212 of file core_rpc_server.cpp.

   {
     const void* buf = start_buff;
     const void* end=(const char*)buf+buflen;
     if (patlen > buflen || patlen == 0) return 0;
     while(buflen>0 && (buf=memchr(buf,((const char*)pat)[0],buflen-patlen+1)))
     {
       if(memcmp(buf,pat,patlen)==0)
         return (const char*)buf - (const char*)start_buff;
       buf=(const char*)buf+1;
       buflen = (const char*)end - (const char*)buf;
     }
     return 0;
   }

Here is the caller graph for this function:

◆ sort_tx_extra()

bool cryptonote::sort_tx_extra	(	const std::vector< uint8_t > &	tx_extra,
		std::vector< uint8_t > &	sorted_tx_extra,
		bool	allow_partial
	)

Definition at line 445 of file cryptonote_format_utils.cpp.

   {
     std::vector<tx_extra_field> tx_extra_fields;
  
     if(tx_extra.empty())
     {
       sorted_tx_extra.clear();
       return true;
     }
  
     std::string extra_str(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size());
     std::istringstream iss(extra_str);
     binary_archive<false> ar(iss);
  
     bool eof = false;
     size_t processed = 0;
     while (!eof)
     {
       tx_extra_field field;
       bool r = ::do_serialize(ar, field);
       if (!r)
       {
         MWARNING("failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
         if (!allow_partial)
           return false;
         break;
       }
       tx_extra_fields.push_back(field);
       processed = iss.tellg();
  
       std::ios_base::iostate state = iss.rdstate();
       eof = (EOF == iss.peek());
       iss.clear(state);
     }
     if (!::serialization::check_stream_state(ar))
     {
       MWARNING("failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
       if (!allow_partial)
         return false;
     }
     MTRACE("Sorted " << processed << "/" << tx_extra.size());
  
     std::ostringstream oss;
     binary_archive<true> nar(oss);
  
     // sort by:
     if (!pick<tx_extra_pub_key>(nar, tx_extra_fields, TX_EXTRA_TAG_PUBKEY)) return false;
     if (!pick<tx_extra_additional_pub_keys>(nar, tx_extra_fields, TX_EXTRA_TAG_ADDITIONAL_PUBKEYS)) return false;
     if (!pick<tx_extra_nonce>(nar, tx_extra_fields, TX_EXTRA_NONCE)) return false;
     if (!pick<tx_extra_merge_mining_tag>(nar, tx_extra_fields, TX_EXTRA_MERGE_MINING_TAG)) return false;
     if (!pick<tx_extra_mysterious_minergate>(nar, tx_extra_fields, TX_EXTRA_MYSTERIOUS_MINERGATE_TAG)) return false;
     if (!pick<tx_extra_padding>(nar, tx_extra_fields, TX_EXTRA_TAG_PADDING)) return false;
  
     // if not empty, someone added a new type and did not add a case above
     if (!tx_extra_fields.empty())
     {
       MERROR("tx_extra_fields not empty after sorting, someone forgot to add a case above");
       return false;
     }
  
     std::string oss_str = oss.str();
     if (allow_partial && processed < tx_extra.size())
     {
       MDEBUG("Appending unparsed data");
       oss_str += std::string((const char*)tx_extra.data() + processed, tx_extra.size() - processed);
     }
     sorted_tx_extra = std::vector<uint8_t>(oss_str.begin(), oss_str.end());
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ t_serializable_object_from_blob()

template<class t_object >

bool cryptonote::t_serializable_object_from_blob	(	t_object &	to,
		const blobdata &	b_blob
	)

Definition at line 147 of file cryptonote_format_utils.h.

   {
     std::stringstream ss;
     ss << b_blob;
     binary_archive<false> ba(ss);
     bool r = ::serialization::serialize(ba, to);
     return r;
   }

Here is the call graph for this function:

◆ t_serializable_object_to_blob() [1/2]

template<class t_object >

blobdata cryptonote::t_serializable_object_to_blob ( const t_object & to )

Definition at line 167 of file cryptonote_format_utils.h.

   {
     blobdata b;
     t_serializable_object_to_blob(to, b);
     return b;
   }

Here is the call graph for this function:

◆ t_serializable_object_to_blob() [2/2]

template<class t_object >

bool cryptonote::t_serializable_object_to_blob	(	const t_object &	to,
		blobdata &	b_blob
	)

Definition at line 157 of file cryptonote_format_utils.h.

   {
     std::stringstream ss;
     binary_archive<true> ba(ss);
     bool r = ::serialization::serialize(ba, const_cast<t_object&>(to));
     b_blob = ss.str();
     return r;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tx_sanity_check()

bool cryptonote::tx_sanity_check	(	Blockchain &	blockchain,
		const cryptonote::blobdata &	tx_blob
	)

Definition at line 42 of file tx_sanity_check.cpp.

 {
   cryptonote::transaction tx;
  
   if (!cryptonote::parse_and_validate_tx_from_blob(tx_blob, tx))
   {
     MERROR("Failed to parse transaction");
     return false;
   }
  
   if (cryptonote::is_coinbase(tx))
   {
     MERROR("Transaction is coinbase");
     return false;
   }
   std::set<uint64_t> rct_indices;
   size_t n_indices = 0;
  
   for (const auto &txin : tx.vin)
   {
     if (txin.type() != typeid(cryptonote::txin_to_key))
       continue;
     const cryptonote::txin_to_key &in_to_key = boost::get<cryptonote::txin_to_key>(txin);
     if (in_to_key.amount != 0)
       continue;
     const std::vector<uint64_t> absolute = cryptonote::relative_output_offsets_to_absolute(in_to_key.key_offsets);
     for (uint64_t offset: absolute)
       rct_indices.insert(offset);
     n_indices += in_to_key.key_offsets.size();
   }
  
   if (tx.version < 3 && n_indices <= 10)
   {
     MERROR("n_indices is only " << n_indices);
     return true;
   }
  
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tx_to_blob() [1/2]

blobdata cryptonote::tx_to_blob ( const transaction & tx )

Definition at line 1246 of file cryptonote_format_utils.cpp.

   {
     return t_serializable_object_to_blob(tx);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tx_to_blob() [2/2]

bool cryptonote::tx_to_blob	(	const transaction &	tx,
		blobdata &	b_blob
	)

Definition at line 1251 of file cryptonote_format_utils.cpp.

   {
     return t_serializable_object_to_blob(tx, b_blob);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ arg_block_download_max_size

const command_line::arg_descriptor< size_t > cryptonote::arg_block_download_max_size

Initial value:

= {
    "block-download-max-size"
  , "Set maximum size of block download queue in bytes (0 for default)"
  , 0
  }

Definition at line 117 of file cryptonote_core.cpp.

◆ arg_data_dir

const command_line::arg_descriptor< std::string, false, true, 2 > cryptonote::arg_data_dir

Initial value:

= {
    "data-dir"
  , "Specify data directory"
  , tools::get_default_data_dir()
  , {{ &arg_testnet_on, &arg_stagenet_on }}
  , [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val)->std::string {
      if (testnet_stagenet[0])
        return (boost::filesystem::path(val) / "testnet").string();
      else if (testnet_stagenet[1])
        return (boost::filesystem::path(val) / "stagenet").string();
      return val;
    }
  }

Definition at line 96 of file cryptonote_core.cpp.

◆ arg_db_salvage

const command_line::arg_descriptor< bool, false > cryptonote::arg_db_salvage

Initial value:

= {
  "db-salvage"
, "Try to salvage a blockchain database if it seems corrupted"
, false
}

Definition at line 94 of file blockchain_db.cpp.

◆ arg_db_sync_mode

const command_line::arg_descriptor< std::string > cryptonote::arg_db_sync_mode

Initial value:

= {
  "db-sync-mode"
, "Specify sync option, using format [safe|fast|fastest]:[sync|async]:[<nblocks_per_sync>[blocks]|<nbytes_per_sync>[bytes]]." 
, "fast:async:250000000bytes"
}

Definition at line 89 of file blockchain_db.cpp.

◆ arg_db_type

const command_line::arg_descriptor< std::string > cryptonote::arg_db_type

Initial value:

= {
  "db-type"
, arg_db_type_description.c_str()
, DEFAULT_DB_TYPE
}

Definition at line 84 of file blockchain_db.cpp.

◆ arg_db_type_description

std::string cryptonote::arg_db_type_description = "Specify database type, available: " + cryptonote::blockchain_db_types(", ")

Definition at line 83 of file blockchain_db.cpp.

◆ arg_disable_dns_checkpoints

const command_line::arg_descriptor<bool> cryptonote::arg_disable_dns_checkpoints

Initial value:

= {
    "disable-dns-checkpoints"
  , "Do not retrieve checkpoints from DNS"
  }

Definition at line 113 of file cryptonote_core.cpp.

◆ arg_fallback_to_pow

const command_line::arg_descriptor< bool > cryptonote::arg_fallback_to_pow

Initial value:

= {
    "fallback-to-pow"
    , "Disables all Validator feature and fallback consensus to standard Proof-of-Work (CryptoNote V1)."
      "This argument is a decentralization safety measure in case something happens with Electroneum Ltd"
      "so that users can fork the network to Proof of Work. (Anti Meteor Feature)."
      "Before using this flag, please determine whether or not you want to use a checkpoint for the PoW fork (--fallback-to-pow-checkpoint-hash and --fallback-to-pow-checkpoint-height)"
      "Please note that this is only a temporary solution so that people can continue the chain in a sensible decentralised way immediately if Electroneum ceased to exist. Long term solutions are explained in our docs folder"
      "***WARNING: IF YOU USE THIS ARGUMENT AND MINE BLOCKS AND LATER WISH TO RETURN TO THE TIP OF THE V8 *MODERATED* BLOCKCHAIN, YOU WILL HAVE TO MANUALLY POP BLOCKS BACK USING THE DAEMON (OR IMPORT) PROGRAM"
    , false
  }

Definition at line 223 of file cryptonote_core.cpp.

◆ arg_fallback_to_pow_checkpoint_hash

const command_line::arg_descriptor< std::string > cryptonote::arg_fallback_to_pow_checkpoint_hash

Initial value:

= {
            "fallback-to-pow-checkpoint-hash"
            , "Used in conjunction with --fallback-to-pow. This flag allows you to specify the *hash* of a checkpoint that would mark the new beginning of the PoW chain agreed upon by the community"
            , ""
  }

Definition at line 240 of file cryptonote_core.cpp.

◆ arg_fallback_to_pow_checkpoint_height

const command_line::arg_descriptor< uint64_t > cryptonote::arg_fallback_to_pow_checkpoint_height

Initial value:

= {
            "fallback-to-pow-checkpoint-height"
            , "Used in conjunction with --fallback-to-pow. This flag allows you to specify the *height* of a checkpoint that would mark the new beginning of the PoW chain agreed upon by the community"
            , 0
  }

Definition at line 234 of file cryptonote_core.cpp.

◆ arg_fixed_difficulty

const command_line::arg_descriptor< difficulty_type > cryptonote::arg_fixed_difficulty

Initial value:

= {
    "fixed-difficulty"
  , "Fixed difficulty used for testing."
  , 0
  }

Definition at line 86 of file cryptonote_core.cpp.

◆ arg_offline

const command_line::arg_descriptor< bool > cryptonote::arg_offline

Initial value:

= {
    "offline"
  , "Do not listen for peers, nor connect to any"
  }

Definition at line 109 of file cryptonote_core.cpp.

◆ arg_regtest_on

const command_line::arg_descriptor< bool, false > cryptonote::arg_regtest_on

Initial value:

= {
    "regtest"
  , "Run in a regression testing mode."
  , false
  }

Definition at line 81 of file cryptonote_core.cpp.

◆ arg_skip_block_sig_verification

const command_line::arg_descriptor< bool > cryptonote::arg_skip_block_sig_verification

Initial value:

= {
      "ignore-bsig"
          , "Ignore block signature & signatory verification. Used for testing."
          , false
  }

Definition at line 91 of file cryptonote_core.cpp.

◆ arg_stagenet_on

const command_line::arg_descriptor< bool, false > cryptonote::arg_stagenet_on

Initial value:

= {
    "stagenet"
  , "Run on stagenet. The wallet must be launched with --stagenet flag."
  , false
  }

Definition at line 76 of file cryptonote_core.cpp.

◆ arg_testnet_on

const command_line::arg_descriptor< bool, false > cryptonote::arg_testnet_on

Initial value:

= {
    "testnet"
  , "Run on testnet. The wallet must be launched with --testnet flag."
  , false
  }

Definition at line 71 of file cryptonote_core.cpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ acc_outs_t

◆ blk_height

◆ blobdata

◆ blobdata_ref

◆ core_stat_info

◆ difficulty_type

◆ GetCheckpointsCallback

◆ mdb_block_info

◆ mdb_block_info_1

◆ mdb_block_info_2

◆ mdb_block_info_3

◆ mdb_block_info_4

◆ mdb_rflags

◆ mdb_threadinfo

◆ mdb_txn_cursors

◆ outkey

◆ outtx

◆ pre_rct_outkey

◆ ring_signature

◆ sorted_tx_container

◆ tx_by_fee_and_receive_time_entry

◆ tx_extra_field

◆ tx_out_index

◆ txin_v

◆ txindex

◆ txout_target_v

Enumeration Type Documentation

◆ anonymous enum

◆ blockchain_db_sync_mode

◆ network_type

Function Documentation

◆ absolute_output_offsets_to_relative()

◆ add_additional_tx_pub_keys_to_extra()

◆ add_extra_nonce_to_tx_extra()

◆ add_tx_pub_key_to_extra() [1/3]

◆ add_tx_pub_key_to_extra() [2/3]

◆ add_tx_pub_key_to_extra() [3/3]

◆ block_to_blob() [1/2]

◆ block_to_blob() [2/2]

◆ blockchain_db_types()

◆ blockchain_valid_db_type()

◆ calculate_block_hash()

◆ calculate_multisig_keys()

◆ calculate_multisig_signer_key()

◆ calculate_transaction_hash()

◆ calculate_transaction_prunable_hash()

◆ check_etn_overflow()

◆ check_hash()

◆ check_hash_128()

◆ check_hash_64()

◆ check_inputs_overflow()

◆ check_inputs_types_supported()

◆ check_outs_overflow()

◆ check_outs_valid()

◆ classify_addresses()

◆ construct_miner_tx()

◆ construct_tx()

◆ construct_tx_and_get_tx_key()

◆ construct_tx_with_tx_key()

◆ decompose_amount_into_digits()

◆ decrypt_key()

◆ encrypt_key()

◆ expand_transaction_1()

◆ factorial()

◆ find_tx_extra_field_by_type()

◆ generate_genesis_block()

◆ generate_key_image_helper()

◆ generate_key_image_helper_precomp()

◆ generate_multisig_composite_key_image()

◆ generate_multisig_derivations()

◆ generate_multisig_key_image()

◆ generate_multisig_LR()