cryptonote Namespace Reference

Holds cryptonote related classes and helpers. More...

Namespaces
namespace	bootstrap
namespace	rpc
namespace	json

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	ADDR_TX_EXISTS
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	acc_addr_tx_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	address_txs
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_bridge_source_address
struct	tx_extra_bridge_smartchain_address
struct	tx_extra_bridge_ownership_sig
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	public_output
struct	COMMAND_RPC_IS_PUBLIC_OUTPUT_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_ADDR_TX_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_GET_TAX_DATA
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...
class	vector
	STL 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::acc_addr_tx_t	acc_addr_tx_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_bridge_source_address, tx_extra_bridge_smartchain_address, tx_extra_bridge_ownership_sig, 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.
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
typedef std::set< tx_by_fee_and_receive_time_entry, txCompare >	sorted_tx_container
	container for sorting transactions by fee per unit size

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 }
enum	SPENT_STATUS { UNSPENT = 0 , SPENT_IN_BLOCKCHAIN = 1 , SPENT_IN_POOL = 2 }

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	add_bridge_source_address_to_tx_extra (std::vector< uint8_t > &tx_extra, const blobdata &bridge_source_address)
bool	add_bridge_smartchain_address_to_tx_extra (std::vector< uint8_t > &tx_extra, const blobdata &bridge_smartchain_address)
bool	add_bridge_ownership_sig_to_tx_extra (std::vector< uint8_t > &tx_extra, const crypto::signature &sig)
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)
bool	sort_tx_extra (const std::vector< uint8_t > &tx_extra, std::vector< uint8_t > &sorted_tx_extra, bool allow_partial=false)
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
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)
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	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, const uint32_t account_major_offset=0, const cryptonote::network_type=MAINNET)
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, const cryptonote::network_type=MAINNET)
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
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)
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
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 >	arg_addr_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_addr_tx_t

typedef struct cryptonote::acc_addr_tx_t cryptonote::acc_addr_tx_t

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 355 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_bridge_source_address, tx_extra_bridge_smartchain_address, tx_extra_bridge_ownership_sig, tx_extra_mysterious_minergate> cryptonote::tx_extra_field

Definition at line 217 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 107 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 223 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 225 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 2641 of file db_lmdb.cpp.

{ 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).

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 246 of file cryptonote_config.h.

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

SPENT_STATUS

enum cryptonote::SPENT_STATUS

Enumerator
UNSPENT
SPENT_IN_BLOCKCHAIN
SPENT_IN_POOL

Definition at line 403 of file core_rpc_server_commands_defs.h.

                      {
        UNSPENT = 0,
        SPENT_IN_BLOCKCHAIN = 1,
        SPENT_IN_POOL = 2,
    };

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

Here is the caller graph for this function:

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 575 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:

Here is the caller graph for this function:

add_bridge_ownership_sig_to_tx_extra()

bool cryptonote::add_bridge_ownership_sig_to_tx_extra	(	std::vector< uint8_t > &	tx_extra,
		const crypto::signature &	sig )

Definition at line 640 of file cryptonote_format_utils.cpp.

    {
        size_t start_pos = tx_extra.size();
        tx_extra.resize(tx_extra.size() + 2 + sizeof(crypto::signature));
        //write tag
        tx_extra[start_pos] = TX_EXTRA_TAG_BRIDGE_OWNERSHIP_SIG;
        //write len
        ++start_pos;
        tx_extra[start_pos] = static_cast<uint8_t>(sizeof(crypto::signature));
        //write data
        ++start_pos;
        memcpy(&tx_extra[start_pos], &sig, sizeof(crypto::signature));
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

add_bridge_smartchain_address_to_tx_extra()

bool cryptonote::add_bridge_smartchain_address_to_tx_extra	(	std::vector< uint8_t > &	tx_extra,
		const blobdata &	bridge_smartchain_address )

Definition at line 624 of file cryptonote_format_utils.cpp.

    {
        //CHECK_AND_ASSERT_MES(bridge_smartchain_address.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 + bridge_smartchain_address.size());
        //write tag
        tx_extra[start_pos] = TX_EXTRA_TAG_BRIDGE_SMARTCHAIN_ADDRESS;
        //write len
        ++start_pos;
        tx_extra[start_pos] = static_cast<uint8_t>(bridge_smartchain_address.size());
        //write data
        ++start_pos;
        memcpy(&tx_extra[start_pos], bridge_smartchain_address.data(), bridge_smartchain_address.size());
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

add_bridge_source_address_to_tx_extra()

bool cryptonote::add_bridge_source_address_to_tx_extra	(	std::vector< uint8_t > &	tx_extra,
		const blobdata &	bridge_source_address )

Definition at line 608 of file cryptonote_format_utils.cpp.

    {
        //CHECK_AND_ASSERT_MES(bridge_source_address.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 + bridge_source_address.size());
        //write tag
        tx_extra[start_pos] = TX_EXTRA_TAG_BRIDGE_SOURCE_ADDRESS;
        //write len
        ++start_pos;
        tx_extra[start_pos] = static_cast<uint8_t>(bridge_source_address.size());
        //write data
        ++start_pos;
        memcpy(&tx_extra[start_pos], bridge_source_address.data(), bridge_source_address.size());
        return true;
    }

Here is the call graph for this function:

Here is the caller 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 592 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 550 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;
  }

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 540 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 545 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 1286 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 1291 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 71 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 60 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 1190 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 1092 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 1025 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 803 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 808 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 751 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 833 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 771 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 55 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 81 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 694 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() [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,
		const cryptonote::network_type	nettype )

Definition at line 666 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_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,
		const cryptonote::network_type	= MAINNET )

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,
		const cryptonote::network_type	nettype )

Definition at line 222 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))
    {
        // IS TX GOING TO THE SMARTCHAIN BRIDGE? IF SO ADD THE ETN ADDRESS AND NEW SMARTCHAIN ADDRESS TO TX EXTRA:
        // Portal address is derived from the genesis block hash of the mainnet so nobody knows the private key.
        cryptonote::account_public_address portal_address;
        crypto::hash h;
        crypto::ec_point point;
        if(nettype == MAINNET){
            epee::string_tools::hex_to_pod("a2050dacd6a36b6fc71cd6447ee498fb2c42801b74e8fe921213f4fcbd95ddcc", h); // v9 fork
        }else{
            epee::string_tools::hex_to_pod("1c5da5c1e1420653825260b8ffc85499fdfb6457153a7df9720e659075b3ce76", h); // genesis hash hex ---> hash type --
        }
        crypto::hash_to_point(h, point); // generate curve point (burn address spendkey) deterministically in such a way that we can't recover the private key
        crypto::public_key portal_address_spendkey;
        std::copy(std::begin(point.data), std::end(point.data), std::begin(portal_address_spendkey.data)); // serialise point to pubkey type
        std::string portal_address_spendkey_hex_str = epee::string_tools::pod_to_hex(portal_address_spendkey); // for testing only. pub spend =
        std::string portal_address_viewkey_hex_str;
        if(nettype == MAINNET){
            portal_address_viewkey_hex_str = "2b95a2eb2c62253c57e82b082b850bbf22a1a7829aaea09c7c1511c1cced4375"; //private view is just e5c8af002654f38ec39ac80edbbcd0c03c9b483379d297af0c3ca15568c7300e -
        }else{
            portal_address_viewkey_hex_str = "5866666666666666666666666666666666666666666666666666666666666666"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000 -
        }
        portal_address.m_spend_public_key = portal_address_spendkey;
        epee::string_tools::hex_to_pod(portal_address_viewkey_hex_str, portal_address.m_view_public_key);
        cryptonote::account_public_address dest_address = destinations[0].addr;
 
        // Grab the full etnk.... address as a string, which we serialise to the extra as bytestring
        // Also use secp256k1 library to take their electroneum private key (which will become their smartchain private key)
        // and use it to create a secp256k1 public key... Then use the public key to
        // generate their smartchain address 0xABC1D........ and put this in the tx extra in the same fashion
        // NB the curve private key domain of ed25519 is a subset of that of secp256k1, and therefore no extra modulo
        // operation is needed before generating the smartchain public key.
        // This code uses generates an Ethereum address by taking the last 20 bytes of the Keccak-256 hash of the public key
        // and adding the prefix "0x".
        if(dest_address == portal_address){
            LOG_PRINT_L1("Sending a migration transaction:");
            crypto::secret_key k = sender_account_keys.m_spend_secret_key; // example private key (can hardcode): 5810ba5a47a45a256458dffe9be21b341a7d74c0b9a8b6a232c60474acbed203
            std::string seckeystring = epee::string_tools::pod_to_hex(sender_account_keys.m_spend_secret_key); //debug purposes
 
            // SOURCE ADDRESS
            std::string bridge_source_address = cryptonote::get_account_address_as_str(nettype, false, sender_account_keys.m_account_address); //OK
            add_bridge_source_address_to_tx_extra(tx.extra, bridge_source_address); //OK
            LOG_PRINT_L1("Source address: " << bridge_source_address);
 
            // SMARTCHAIN ADDRESS
            unsigned char seckey1[32];
            unsigned char public_key64[65];
            size_t pk_len = 65;
            secp256k1_pubkey pubkey1;
            secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
            memcpy(seckey1, sender_account_keys.m_spend_secret_key.data, 32);
            if(secp256k1_ec_seckey_verify(ctx, seckey1) == 0) { // sec key has an unrealistic chance of being invalid (10^-128) https://en.bitcoin.it/wiki/Private_key
                LOG_ERROR("Invalid private key");
                return false;
            }
 
            // create the pubkey and serialise it
            if(secp256k1_ec_pubkey_create(ctx, &pubkey1, seckey1) == 0) { // this format is not sufficient for hashing, hence serialisation
              LOG_ERROR("Failed to create secp256k1 public key");
              return false;
            }
            secp256k1_ec_pubkey_serialize(ctx, public_key64, &pk_len, &pubkey1, SECP256K1_EC_UNCOMPRESSED); // serialise pubkey1 into publickey_64
            std::string long_public_key2 = epee::string_tools::pod_to_hex(public_key64); // debug purposes - can check against https://lab.miguelmota.com/ethereum-private-key-to-public-key/example/
 
            // Ethereum address generation: Take the last 20 bytes of the Keccak-256 hash of the public key
            // keccak-1600() is not suitable, but keccak() with 24 rounds and mdlen (=size) of 32 is the same
            // as keccak-256 with a 32 byte output. 24 rounds is the default in Monero for keccak()
            // the first byte is the compression type so hash the 64 bytes after the first byte only
            // I have put the 32 byte hash inside  pubkey1.data just to save time
            keccak(public_key64 + 1, 64, pubkey1.data, 32);
            unsigned char address[20]; //smartchain address
            memcpy(address, pubkey1.data + 12, 20); // take the last 20 bytes of the 32 byte array for the address
            std::string hex_address = epee::string_tools::pod_to_hex(address); // should be 0x12ed7467c3852e6b2Bd3C22AF694be8DF7637B10.
            std::string bridge_smartchain_address = "0x" + hex_address; //prefix address with 0x
            LOG_PRINT_L1("Smartchain address: " << bridge_smartchain_address);
 
            secp256k1_context_destroy(ctx);
            add_bridge_smartchain_address_to_tx_extra(tx.extra, bridge_smartchain_address);
 
            // OWNERSHIP SIGNATURE: prove the sender owns the source address by signing
            // (bridge_source_address + bridge_smartchain_address) with the spend secret key
            std::string sig_message = bridge_source_address + bridge_smartchain_address;
            crypto::hash sig_hash;
            crypto::cn_fast_hash(sig_message.data(), sig_message.size(), sig_hash);
            crypto::signature ownership_sig;
            crypto::generate_signature(sig_hash, sender_account_keys.m_account_address.m_spend_public_key, sender_account_keys.m_spend_secret_key, ownership_sig);
            add_bridge_ownership_sig_to_tx_extra(tx.extra, ownership_sig);
            LOG_PRINT_L1("Bridge ownership signature added to tx_extra");
        }
 
      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:

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,
		const uint32_t	account_major_offset = 0,
		const cryptonote::network_type	= MAINNET )

Here is the call 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 212 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 1354 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 1346 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 1927 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 704 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 call graph for this function:

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 558 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 570 of file cryptonote_format_utils.cpp.

  {
    return get_additional_tx_pub_keys_from_extra(tx.extra);
  }

Here is the call graph for this function:

get_blob_hash() [1/4]

crypto::hash cryptonote::get_blob_hash

(

const blobdata &

blob

)

Definition at line 998 of file cryptonote_format_utils.cpp.

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

Here is the call graph for this function:

get_blob_hash() [2/4]

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

Definition at line 947 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 1005 of file cryptonote_format_utils.cpp.

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

Here is the call graph for this function:

get_blob_hash() [4/4]

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

Definition at line 942 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 1406 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 1215 of file cryptonote_format_utils.cpp.

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

Here is the call graph for this function:

get_block_hash() [2/2]

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

Definition at line 1195 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 1181 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 744 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 1222 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 1250 of file cryptonote_format_utils.cpp.

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

Here is the call graph for this function:

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 266 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 964 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 200 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;
  }

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 712 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 1338 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 722 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 call graph for this function:

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

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 185 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 178 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 192 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 845 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 702 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 1057 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 1012 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 call graph for this function:

get_transaction_hash() [2/4]

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

Definition at line 1020 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 1176 of file cryptonote_format_utils.cpp.

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

Here is the call 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 1142 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 call 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 1050 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;
  }

Here is the call graph for this function:

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 518 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 535 of file cryptonote_format_utils.cpp.

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

Here is the call 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 530 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 1318 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 call 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 1311 of file cryptonote_format_utils.cpp.

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

Here is the call graph for this function:

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 1306 of file cryptonote_format_utils.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_unit()

std::string cryptonote::get_unit

(

unsigned int

decimal_point

)

Definition at line 969 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 243 of file cryptonote_basic.h.

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

getpos() [2/2]

template<>

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

inline

Definition at line 242 of file cryptonote_basic.h.

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

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 862 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 885 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 905 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()});
  }

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:

is_valid_decomposed_amount()

bool cryptonote::is_valid_decomposed_amount

(

uint64_t

amount

)

Definition at line 1331 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 502 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 call graph for this function:

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 527 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 call graph for this function:

Here is the caller graph for this function:

lmdb_txn_renew()

int cryptonote::lmdb_txn_renew ( MDB_txn * txn )

inline

Definition at line 537 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 924 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:

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

Here is the caller graph for this function:

new_db()

BlockchainDB * cryptonote::new_db

(

const std::string &

db_type

)

Definition at line 107 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()

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

Here is the caller graph for this function:

obj_to_json_str()

template<typename T>

std::string cryptonote::obj_to_json_str

(

T &

obj

)

Definition at line 201 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 1276 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 1281 of file cryptonote_format_utils.cpp.

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

Here is the call 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 1257 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 984 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 1230 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 655 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:

Here is the caller graph for this function:

set_default_decimal_point()

void cryptonote::set_default_decimal_point

(

unsigned int

decimal_point

)

Definition at line 952 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 694 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));
  }

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

short_hash_str()

std::string cryptonote::short_hash_str

(

const crypto::hash &

h

)

Definition at line 853 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 1315 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() [1/2]

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_bridge_source_address>(nar, tx_extra_fields, TX_EXTRA_TAG_BRIDGE_SOURCE_ADDRESS)) return false;
    if (!pick<tx_extra_bridge_smartchain_address>(nar, tx_extra_fields, TX_EXTRA_TAG_BRIDGE_SMARTCHAIN_ADDRESS)) return false;
    if (!pick<tx_extra_bridge_ownership_sig>(nar, tx_extra_fields, TX_EXTRA_TAG_BRIDGE_OWNERSHIP_SIG)) 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:

sort_tx_extra() [2/2]

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

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 150 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 170 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 160 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 1296 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 1301 of file cryptonote_format_utils.cpp.

  {
    return t_serializable_object_to_blob(tx, b_blob);
  }

Here is the call graph for this function:

Variable Documentation

arg_addr_db_salvage

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

Initial value:

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

Definition at line 101 of file blockchain_db.cpp.

                                                            {
  "addr-db-salvage"
, "Try to salvage a addr tx database if it seems corrupted"
, false
};

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.

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

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.

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

Definition at line 95 of file blockchain_db.cpp.

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

Definition at line 90 of file blockchain_db.cpp.

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

Definition at line 85 of file blockchain_db.cpp.

                                                        {
  "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(", ")

Definition at line 84 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.

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

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.

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

Definition at line 240 of file cryptonote_core.cpp.

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

Definition at line 234 of file cryptonote_core.cpp.

                                                                                    {
            "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_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.

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

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.

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

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.

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

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.

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

Definition at line 76 of file cryptonote_core.cpp.

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

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.

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