cryptonote Namespace Reference

Holds cryptonote related classes and helpers. More...

Namespaces
	anonymous_namespace{cryptonote_basic_impl.h}
	anonymous_namespace{miner.cpp}
	anonymous_namespace{rpc_args.cpp}
	anonymous_namespace{tx_pool.cpp}
	anonymous_namespace{zmq_server.cpp}
	bootstrap
	json
	rpc

Classes
struct	bdb_txn_safe
class	bdb_safe_buffer
class	bdb_safe_buffer_autolock
class	BlockchainBDB
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...
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	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	txindex
struct	mdb_txn_cursors
struct	mdb_rflags
struct	mdb_threadinfo
struct	mdb_txn_safe
class	BlockchainLMDB
class	BaseTestDB
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	txout_to_script
struct	txout_to_scripthash
struct	txout_to_key
struct	txin_gen
struct	txin_to_script
struct	txin_to_scripthash
struct	txin_to_key
struct	tx_out
struct	validator_db
class	transaction_prefix
class	transaction
struct	block_header
struct	block
struct	account_public_address
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_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::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_v
typedef boost::variant< txout_to_script, txout_to_scripthash, txout_to_key >	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
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)
static bool	is_v1_tx (MDB_cursor *c_txs_pruned, MDB_val *tx_id)
static void	derive_key (const crypto::chacha_key &base_key, crypto::chacha_key &key)
static epee::wipeable_string	get_key_stream (const crypto::chacha_key &base_key, const crypto::chacha_iv &iv, size_t bytes)
std::string	get_protocol_state_string (cryptonote_connection_context::state s)
char	get_protocol_state_char (cryptonote_connection_context::state s)
template<typename T >
static unsigned int	getpos (T &ar)
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)
static unsigned char *	operator& (ec_point &point)
static const unsigned char *	operator& (const ec_point &point)
static void	add_public_key (crypto::public_key &AB, const crypto::public_key &A, const crypto::public_key &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)
template<typename T >
static bool	pick (binary_archive< true > &ar, std::vector< tx_extra_field > &fields, uint8_t tag)
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_money_amount (const transaction &tx, uint64_t &money)
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_money_overflow (const transaction &tx)
bool	check_inputs_overflow (const transaction &tx)
bool	check_outs_overflow (const transaction &tx)
uint64_t	get_outs_money_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)
bool	lookup_acc_outs (const account_keys &acc, const transaction &tx, std::vector< size_t > &outs, uint64_t &money_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 &money_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_money (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)
static void	mul (uint64_t a, uint64_t b, uint64_t &low, uint64_t &high)
static bool	cadd (uint64_t a, uint64_t b)
static bool	cadc (uint64_t a, uint64_t b, bool c)
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)
static bool	is_canonical_bulletproof_layout (const std::vector< rct::Bulletproof > &proofs)
block_complete_entry	get_block_complete_entry (block &b, tx_memory_pool &pool)
double	factorial (unsigned int n)
static double	probability1 (unsigned int blocks, unsigned int expected)
static double	probability (unsigned int blocks, unsigned int expected)
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)
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)
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	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=false, const rct::RCTConfig &rct_config={ rct::RangeProofBorromean, 0 }, rct::multisig_out *msout=NULL, bool shuffle_outs=true, uint32_t account_major_offset=0)
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=false, const rct::RCTConfig &rct_config={ rct::RangeProofBorromean, 0 }, rct::multisig_out *msout=NULL, uint32_t account_major_offset=0)
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)
bool	generate_multisig_composite_key_image (const account_keys &keys, const std::unordered_map< crypto::public_key, cryptonote::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)
static bool	operator== (const crypto::public_key &k0, const rct::key &k1)
static bool	operator!= (const crypto::public_key &k0, const rct::key &k1)
static bool	operator== (const crypto::secret_key &k0, const rct::key &k1)
static bool	operator!= (const crypto::secret_key &k0, const rct::key &k1)
size_t	slow_memmem (const void *start_buff, size_t buflen, const void *pat, size_t patlen)

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
static const command_line::arg_descriptor< bool >	arg_test_drop_download
static const command_line::arg_descriptor< uint64_t >	arg_test_drop_download_height
static const command_line::arg_descriptor< int >	arg_test_dbg_lock_sleep
static const command_line::arg_descriptor< bool >	arg_dns_checkpoints
static const command_line::arg_descriptor< uint64_t >	arg_fast_block_sync
static const command_line::arg_descriptor< uint64_t >	arg_prep_blocks_threads
static const command_line::arg_descriptor< uint64_t >	arg_show_time_stats
static const command_line::arg_descriptor< size_t >	arg_block_sync_size
static const command_line::arg_descriptor< std::string >	arg_check_updates
static const command_line::arg_descriptor< bool >	arg_fluffy_blocks
static const command_line::arg_descriptor< bool >	arg_no_fluffy_blocks
static const command_line::arg_descriptor< bool >	arg_pad_transactions
static const command_line::arg_descriptor< size_t >	arg_max_txpool_weight
static const command_line::arg_descriptor< std::string >	arg_block_notify
static const command_line::arg_descriptor< bool >	arg_prune_blockchain
static const command_line::arg_descriptor< std::string >	arg_reorg_notify
static const command_line::arg_descriptor< std::string >	arg_block_rate_notify
static const command_line::arg_descriptor< std::string >	arg_validator_key
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

blk_height

typedef struct cryptonote::blk_height cryptonote::blk_height

blobdata

typedef std::string cryptonote::blobdata

blobdata_ref

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

core_stat_info

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

difficulty_type

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

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

mdb_block_info

typedef mdb_block_info_4 cryptonote::mdb_block_info

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

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

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

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

tx_out_index

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

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

txin_v

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

txindex

typedef struct cryptonote::txindex cryptonote::txindex

txout_target_v

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

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
prune_mode_prune
prune_mode_update
prune_mode_check

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)

network_type

enum cryptonote::network_type : uint8_t

Enumerator
MAINNET
TESTNET
STAGENET
FAKECHAIN
UNDEFINED

Function Documentation

absolute_output_offsets_to_relative()

std::vector< uint64_t > cryptonote::absolute_output_offsets_to_relative

(

const std::vector< uint64_t > &

off

)

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
	)

add_extra_nonce_to_tx_extra()

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

add_public_key()

static void cryptonote::add_public_key ( crypto::public_key &  AB, const crypto::public_key &  A, const crypto::public_key &  B  )

static

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
	)

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
	)

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
	)

block_to_blob() [1/2]

blobdata cryptonote::block_to_blob

(

const block &

b

)

block_to_blob() [2/2]

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

blockchain_db_types()

std::string cryptonote::blockchain_db_types

(

const std::string &

sep

)

blockchain_valid_db_type()

bool cryptonote::blockchain_valid_db_type

(

const std::string &

db_type

)

cadc()

static bool cryptonote::cadc ( uint64_t  a, uint64_t  b, bool  c  )

inlinestatic

cadd()

static bool cryptonote::cadd ( uint64_t  a, uint64_t  b  )

inlinestatic

calculate_block_hash()

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

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

calculate_multisig_signer_key()

crypto::secret_key cryptonote::calculate_multisig_signer_key

(

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

multisig_keys

)

calculate_transaction_hash()

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

calculate_transaction_prunable_hash()

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

check_hash()

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

check_hash_128()

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

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

check_inputs_overflow()

bool cryptonote::check_inputs_overflow

(

const transaction &

tx

)

check_inputs_types_supported()

bool cryptonote::check_inputs_types_supported

(

const transaction &

tx

)

check_money_overflow()

bool cryptonote::check_money_overflow

(

const transaction &

tx

)

check_outs_overflow()

bool cryptonote::check_outs_overflow

(

const transaction &

tx

)

check_outs_valid()

bool cryptonote::check_outs_valid

(

const transaction &

tx

)

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
	)

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
	)

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
	)

construct_tx_and_get_tx_key() [1/2]

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
	)

construct_tx_and_get_tx_key() [2/2]

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 = false,
		const rct::RCTConfig &	rct_config = { rct::RangeProofBorromean, 0 },
		rct::multisig_out *	msout = NULL,
		uint32_t	account_major_offset = 0
	)

construct_tx_with_tx_key() [1/2]

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
	)

construct_tx_with_tx_key() [2/2]

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 = false,
		const rct::RCTConfig &	rct_config = { rct::RangeProofBorromean, 0 },
		rct::multisig_out *	msout = NULL,
		bool	shuffle_outs = true,
		uint32_t	account_major_offset = 0
	)

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
	)

decrypt_key()

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

derive_key()

static void cryptonote::derive_key ( const crypto::chacha_key &  base_key, crypto::chacha_key &  key  )

static

encrypt_key()

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

expand_transaction_1()

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

factorial()

double cryptonote::factorial

(

unsigned int

n

)

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
	)

generate_genesis_block()

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

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
	)

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
	)

generate_multisig_composite_key_image() [1/2]

bool cryptonote::generate_multisig_composite_key_image	(	const account_keys &	keys,
		const std::unordered_map< crypto::public_key, cryptonote::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
	)

generate_multisig_composite_key_image() [2/2]

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
	)

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

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
	)

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
	)

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

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
	)

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
	)

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
	)

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
	)

get_account_address_checksum()

uint8_t cryptonote::get_account_address_checksum

(

const public_address_outer_blob &

bl

)

get_account_address_from_str()

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

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
	)

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
	)

get_account_integrated_address_checksum()

uint8_t cryptonote::get_account_integrated_address_checksum

(

const public_integrated_address_outer_blob &

bl

)

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

)

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

)

get_blob_hash() [1/4]

crypto::hash cryptonote::get_blob_hash

(

const blobdata &

blob

)

get_blob_hash() [2/4]

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

get_blob_hash() [3/4]

crypto::hash cryptonote::get_blob_hash

(

const epee::span< const char > &

blob

)

get_blob_hash() [4/4]

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

get_block_complete_entry()

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

get_block_hash() [1/2]

crypto::hash cryptonote::get_block_hash

(

const block &

b

)

get_block_hash() [2/2]

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

get_block_hashing_blob()

blobdata cryptonote::get_block_hashing_blob

(

const block &

b

)

get_block_height()

uint64_t cryptonote::get_block_height

(

const block &

b

)

get_block_longhash() [1/2]

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

get_block_longhash() [2/2]

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

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
	)

get_config()

const config_t& cryptonote::get_config ( network_type  nettype )

inline

get_default_decimal_point()

unsigned int cryptonote::get_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
	)

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
	)

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
	)

get_inputs_money_amount()

bool cryptonote::get_inputs_money_amount	(	const transaction &	tx,
		uint64_t &	money
	)

get_key_stream()

static epee::wipeable_string cryptonote::get_key_stream ( const crypto::chacha_key &  base_key, const crypto::chacha_iv &  iv, size_t  bytes  )

static

get_max_tx_size()

size_t cryptonote::get_max_tx_size

(

)

get_min_block_weight()

size_t cryptonote::get_min_block_weight

(

uint8_t

version

)

get_multisig_blinded_secret_key()

crypto::secret_key cryptonote::get_multisig_blinded_secret_key

(

const crypto::secret_key &

key

)

get_object_blobsize()

template<class t_object >

size_t cryptonote::get_object_blobsize

(

const t_object &

o

)

get_object_hash() [1/2]

template<class t_object >

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

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
	)

get_outs_money_amount()

uint64_t cryptonote::get_outs_money_amount

(

const transaction &

tx

)

get_payment_id_from_tx_extra_nonce()

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

get_protocol_state_char()

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

inline

get_protocol_state_string()

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

inline

get_pruned_transaction_hash()

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

get_transaction_hash() [1/4]

crypto::hash cryptonote::get_transaction_hash

(

const transaction &

t

)

get_transaction_hash() [2/4]

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

get_transaction_hash() [3/4]

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

get_transaction_hash() [4/4]

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

get_transaction_prefix_hash() [1/2]

crypto::hash cryptonote::get_transaction_prefix_hash

(

const transaction_prefix &

tx

)

get_transaction_prefix_hash() [2/2]

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

get_transaction_prunable_hash()

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

get_transaction_weight() [1/2]

uint64_t cryptonote::get_transaction_weight

(

const transaction &

tx

)

get_transaction_weight() [2/2]

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

get_tx_fee() [1/2]

uint64_t cryptonote::get_tx_fee

(

const transaction &

tx

)

get_tx_fee() [2/2]

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

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
	)

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
	)

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
	)

get_tx_tree_hash() [1/3]

crypto::hash cryptonote::get_tx_tree_hash

(

const block &

b

)

get_tx_tree_hash() [2/3]

crypto::hash cryptonote::get_tx_tree_hash

(

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

tx_hashes

)

get_tx_tree_hash() [3/3]

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

get_unit()

std::string cryptonote::get_unit

(

unsigned int

decimal_point

)

getpos() [1/3]

template<>

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

inline

getpos() [2/3]

template<>

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

inline

getpos() [3/3]

template<typename T >

static unsigned int cryptonote::getpos ( T &  ar )

inlinestatic

hex()

std::string cryptonote::hex

(

difficulty_type

v

)

is_canonical_bulletproof_layout()

static bool cryptonote::is_canonical_bulletproof_layout ( const std::vector< rct::Bulletproof > &  proofs )

static

is_coinbase()

bool cryptonote::is_coinbase

(

const transaction &

tx

)

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
	)

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
	)

is_v1_tx() [1/3]

bool cryptonote::is_v1_tx

(

const blobdata &

tx_blob

)

is_v1_tx() [2/3]

bool cryptonote::is_v1_tx

(

const blobdata_ref &

tx_blob

)

is_v1_tx() [3/3]

static bool cryptonote::is_v1_tx ( MDB_cursor *  c_txs_pruned, MDB_val *  tx_id  )

static

is_valid_decomposed_amount()

bool cryptonote::is_valid_decomposed_amount

(

uint64_t

amount

)

lmdb_resized()

void cryptonote::lmdb_resized

(

MDB_env *

env

)

lmdb_txn_begin()

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

inline

lmdb_txn_renew()

int cryptonote::lmdb_txn_renew ( MDB_txn *  txn )

inline

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 &	money_transfered
	)

lookup_acc_outs() [2/2]

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

max128bit()

const boost::multiprecision::uint256_t cryptonote::max128bit

(

std::numeric_limits< boost::multiprecision::uint128_t >

::max()

)

max256bit()

const boost::multiprecision::uint512_t cryptonote::max256bit

(

std::numeric_limits< boost::multiprecision::uint256_t >

::max()

)

max64bit()

const difficulty_type cryptonote::max64bit

(

std::numeric_limits< std::uint64_t >

::max()

)

mul()

static void cryptonote::mul ( uint64_t  a, uint64_t  b, uint64_t &  low, uint64_t &  high  )

inlinestatic

multisig_rounds_required()

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

new_db()

BlockchainDB * cryptonote::new_db

(

const std::string &

db_type

)

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
	)

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
	)

obj_to_json_str()

template<typename T >

std::string cryptonote::obj_to_json_str

(

T &

obj

)

operator!=() [1/2]

static bool cryptonote::operator!= ( const crypto::public_key &  k0, const rct::key &  k1  )

inlinestatic

operator!=() [2/2]

static bool cryptonote::operator!= ( const crypto::secret_key &  k0, const rct::key &  k1  )

inlinestatic

operator&() [1/2]

static const unsigned char* cryptonote::operator& ( const ec_point &  point )

inlinestatic

operator&() [2/2]

static unsigned char* cryptonote::operator& ( ec_point &  point )

inlinestatic

operator<<()

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

inline

operator==() [1/4]

static bool cryptonote::operator== ( const crypto::public_key &  k0, const rct::key &  k1  )

inlinestatic

operator==() [2/4]

static bool cryptonote::operator== ( const crypto::secret_key &  k0, const rct::key &  k1  )

inlinestatic

operator==() [3/4]

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

operator==() [4/4]

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

parse_amount()

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

parse_and_validate_block_from_blob() [1/3]

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

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
	)

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
	)

parse_and_validate_tx_base_from_blob()

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

parse_and_validate_tx_from_blob() [1/3]

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

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
	)

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
	)

parse_and_validate_tx_prefix_from_blob()

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

parse_tx_extra()

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

pick()

template<typename T >

static bool cryptonote::pick ( binary_archive< true > &  ar, std::vector< tx_extra_field > &  fields, uint8_t  tag  )

static

power_integral()

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

print_money()

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

probability()

static double cryptonote::probability ( unsigned int  blocks, unsigned int  expected  )

static

probability1()

static double cryptonote::probability1 ( unsigned int  blocks, unsigned int  expected  )

static

relative_output_offsets_to_absolute()

std::vector< uint64_t > cryptonote::relative_output_offsets_to_absolute

(

const std::vector< uint64_t > &

off

)

remove_field_from_tx_extra()

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

set_default_decimal_point()

void cryptonote::set_default_decimal_point

(

unsigned int

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
	)

set_payment_id_to_tx_extra_nonce()

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

short_hash_str()

std::string cryptonote::short_hash_str

(

const crypto::hash &

h

)

slow_memmem()

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

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
	)

t_serializable_object_from_blob()

template<class t_object >

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

t_serializable_object_to_blob() [1/2]

template<class t_object >

blobdata cryptonote::t_serializable_object_to_blob

(

const t_object &

to

)

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
	)

tx_sanity_check()

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

tx_to_blob() [1/2]

blobdata cryptonote::tx_to_blob

(

const transaction &

tx

)

tx_to_blob() [2/2]

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

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
  }

arg_block_notify

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

static

Initial value:

= {
    "block-notify"
  , "Run a program for each new block, '%s' will be replaced by the block hash"
  , ""
  }

arg_block_rate_notify

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

static

Initial value:

= {
    "block-rate-notify"
  , "Run a program when the block rate undergoes large fluctuations. This might "
    "be a sign of large amounts of hash rate going on and off the Electroneum network, "
    "and thus be of potential interest in predicting attacks. %t will be replaced "
    "by the number of minutes for the observation window, %b by the number of "
    "blocks observed within that window, and %e by the number of blocks that was "
    "expected in that window. It is suggested that this notification is used to "
    "automatically increase the number of confirmations required before a payment "
    "is acted upon."
  , ""
  }

arg_block_sync_size

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

static

Initial value:

= {
    "block-sync-size"
  , "How many blocks to sync at once during chain synchronization (0 = adaptive)."
  , 0
  }

arg_check_updates

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

static

Initial value:

= {
    "check-updates"
  , "Check for new versions of electroneum: [disabled|notify|download|update]"
  , "notify"
  }

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

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
}

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

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
}

arg_db_type_description

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

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

arg_dns_checkpoints

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

static

Initial value:

= {
    "enforce-dns-checkpointing"
  , "checkpoints from DNS server will be enforced"
  , false
  }

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
  }

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"
            , ""
  }

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
  }

arg_fast_block_sync

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

static

Initial value:

= {
    "fast-block-sync"
  , "Sync up most of the way by using embedded, known block hashes."
  , 1
  }

arg_fixed_difficulty

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

Initial value:

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

arg_fluffy_blocks

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

static

Initial value:

= {
    "fluffy-blocks"
  , "Relay blocks as fluffy blocks (obsolete, now default)"
  , true
  }

arg_max_txpool_weight

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

static

Initial value:

= {
    "max-txpool-weight"
  , "Set maximum txpool weight in bytes."
  , DEFAULT_TXPOOL_MAX_WEIGHT
  }

arg_no_fluffy_blocks

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

static

Initial value:

= {
    "no-fluffy-blocks"
  , "Relay blocks as normal blocks"
  , false
  }

arg_offline

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

Initial value:

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

arg_pad_transactions

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

static

Initial value:

= {
    "pad-transactions"
  , "Pad relayed transactions to help defend against traffic volume analysis"
  , false
  }

arg_prep_blocks_threads

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

static

Initial value:

= {
    "prep-blocks-threads"
  , "Max number of threads to use when preparing block hashes in groups."
  , 4
  }

arg_prune_blockchain

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

static

Initial value:

= {
    "prune-blockchain"
  , "Prune blockchain"
  , false
  }

arg_regtest_on

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

Initial value:

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

arg_reorg_notify

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

static

Initial value:

= {
    "reorg-notify"
  , "Run a program for each reorg, '%s' will be replaced by the split height, "
    "'%h' will be replaced by the new blockchain height, '%n' will be "
    "replaced by the number of new blocks in the new chain, and '%d' will be "
    "replaced by the number of blocks discarded from the old chain"
  , ""
  }

arg_show_time_stats

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

static

Initial value:

= {
    "show-time-stats"
  , "Show time-stats when processing blocks/txs and disk synchronization."
  , 0
  }

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
  }

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
  }

arg_test_dbg_lock_sleep

const command_line::arg_descriptor<int> cryptonote::arg_test_dbg_lock_sleep

static

Initial value:

= {
    "test-dbg-lock-sleep"
  , "Sleep time in ms, defaults to 0 (off), used to debug before/after locking mutex. Values 100 to 1000 are good for tests."
  , 0
  }

arg_test_drop_download

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

static

Initial value:

= {
    "test-drop-download"
  , "For net tests: in download, discard ALL blocks instead checking/saving them (very fast)"
  }

arg_test_drop_download_height

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

static

Initial value:

= {
    "test-drop-download-height"
  , "Like test-drop-download but discards only after around certain height"
  , 0
  }

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
  }

arg_validator_key

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

static

Initial value:

= {
    "validator-key"
  , "Validator Key"
  , ""
  }