#include <wallet2.h>

Classes
struct	address_book_row

struct	address_tx

struct	cache_file_data

struct	confirmed_transfer_details

struct	is_out_data

struct	keys_file_data

struct	multisig_info

struct	multisig_sig

struct	multisig_tx_set

struct	parsed_block

struct	payment_details

struct	pending_tx

struct	pool_payment_details

struct	reserve_proof_entry

struct	signed_tx_set

struct	transfer_details

struct	tx_cache_data

struct	tx_construction_data

struct	tx_scan_info_t

struct	unconfirmed_transfer_details

struct	unsigned_tx_set

Public Types
enum	RefreshType { RefreshFull , RefreshOptimizeCoinbase , RefreshNoCoinbase , RefreshDefault = RefreshOptimizeCoinbase }

enum	AskPasswordType { AskPasswordNever = 0 , AskPasswordOnAction = 1 , AskPasswordToDecrypt = 2 }

enum	BackgroundMiningSetupType { BackgroundMiningMaybe = 0 , BackgroundMiningYes = 1 , BackgroundMiningNo = 2 }

typedef std::vector< transfer_details >	transfer_container

typedef std::unordered_multimap< crypto::hash, payment_details >	payment_container

typedef std::tuple< uint64_t, crypto::public_key, rct::key >	get_outs_entry

Public Member Functions
	wallet2 (cryptonote::network_type nettype=cryptonote::MAINNET, uint64_t kdf_rounds=1, bool unattended=false)

	~wallet2 ()

void	generate (const std::string &wallet_, const epee::wipeable_string &password, const epee::wipeable_string &multisig_data, bool create_address_file=false)
	Generates a wallet or restores one. More...

crypto::secret_key	generate (const std::string &wallet, const epee::wipeable_string &password, const crypto::secret_key &recovery_param=crypto::secret_key(), bool recover=false, bool two_random=false, bool create_address_file=false)
	Generates a wallet or restores one. More...

void	generate (const std::string &wallet, const epee::wipeable_string &password, const cryptonote::account_public_address &account_public_address, const crypto::secret_key &spendkey, const crypto::secret_key &viewkey, bool create_address_file=false)
	Creates a wallet from a public address and a spend/view secret key pair. More...

void	generate (const std::string &wallet, const epee::wipeable_string &password, const cryptonote::account_public_address &account_public_address, const crypto::secret_key &viewkey=crypto::secret_key(), bool create_address_file=false)
	Creates a watch only wallet from a public address and a view secret key. More...

void	restore (const std::string &wallet_, const epee::wipeable_string &password, const std::string &device_name, bool create_address_file=false)
	Restore a wallet hold by an HW. More...

std::string	make_multisig (const epee::wipeable_string &password, const std::vector< std::string > &info, uint32_t threshold)
	Creates a multisig wallet. More...

std::string	make_multisig (const epee::wipeable_string &password, const std::vector< crypto::secret_key > &view_keys, const std::vector< crypto::public_key > &spend_keys, uint32_t threshold)
	Creates a multisig wallet. More...

std::string	exchange_multisig_keys (const epee::wipeable_string &password, const std::vector< std::string > &info)

std::string	exchange_multisig_keys (const epee::wipeable_string &password, std::unordered_set< crypto::public_key > pkeys, std::vector< crypto::public_key > signers)
	Any but first round of keys exchange. More...

bool	finalize_multisig (const epee::wipeable_string &password, const std::vector< std::string > &info)
	Finalizes creation of a multisig wallet. More...

bool	finalize_multisig (const epee::wipeable_string &password, const std::unordered_set< crypto::public_key > &pkeys, std::vector< crypto::public_key > signers)
	Finalizes creation of a multisig wallet. More...

std::string	get_multisig_info () const

cryptonote::blobdata	export_multisig ()

size_t	import_multisig (std::vector< cryptonote::blobdata > info)

void	rewrite (const std::string &wallet_name, const epee::wipeable_string &password)
	Rewrites to the wallet file for wallet upgrade (doesn't generate key, assumes it's already there) More...

void	write_watch_only_wallet (const std::string &wallet_name, const epee::wipeable_string &password, std::string &new_keys_filename)
	Writes to a file named based on the normal wallet (doesn't generate key, assumes it's already there) More...

void	load (const std::string &wallet, const epee::wipeable_string &password)

void	store ()

void	store_to (const std::string &path, const epee::wipeable_string &password)
	store_to Stores wallet to another file(s), deleting old ones More...

std::string	path () const

bool	verify_password (const epee::wipeable_string &password)
	verifies given password is correct for default wallet keys file More...

cryptonote::account_base &	get_account ()

const cryptonote::account_base &	get_account () const

void	encrypt_keys (const crypto::chacha_key &key)

void	encrypt_keys (const epee::wipeable_string &password)

void	decrypt_keys (const crypto::chacha_key &key)

void	decrypt_keys (const epee::wipeable_string &password)

void	set_refresh_from_block_height (uint64_t height)

uint64_t	get_refresh_from_block_height () const

void	explicit_refresh_from_block_height (bool expl)

bool	explicit_refresh_from_block_height () const

bool	deinit ()

bool	init (std::string daemon_address="http://localhost:8080", boost::optional< epee::net_utils::http::login > daemon_login=boost::none, boost::asio::ip::tcp::endpoint proxy={}, uint64_t upper_transaction_weight_limit=0, bool trusted_daemon=true, epee::net_utils::ssl_options_t ssl_options=epee::net_utils::ssl_support_t::e_ssl_support_autodetect, std::string blockchain_db_path="")

bool	set_daemon (std::string daemon_address="http://localhost:8080", boost::optional< epee::net_utils::http::login > daemon_login=boost::none, bool trusted_daemon=true, epee::net_utils::ssl_options_t ssl_options=epee::net_utils::ssl_support_t::e_ssl_support_autodetect)

void	stop ()

i_wallet2_callback *	callback () const

void	callback (i_wallet2_callback *callback)

bool	is_trusted_daemon () const

void	set_trusted_daemon (bool trusted)

bool	is_deterministic () const
	Checks if deterministic wallet. More...

bool	get_seed (epee::wipeable_string &electrum_words, const epee::wipeable_string &passphrase=epee::wipeable_string()) const

bool	light_wallet () const
	Checks if light wallet. A light wallet sends view key to a server where the blockchain is scanned. More...

void	set_light_wallet (bool light_wallet)

uint64_t	get_light_wallet_scanned_block_height () const

uint64_t	get_light_wallet_blockchain_height () const

const std::string &	get_seed_language () const
	Gets the seed language. More...

void	set_seed_language (const std::string &language)
	Sets the seed language. More...

cryptonote::account_public_address	get_subaddress (const cryptonote::subaddress_index &index) const

cryptonote::account_public_address	get_address () const

boost::optional< cryptonote::subaddress_index >	get_subaddress_index (const cryptonote::account_public_address &address) const

crypto::public_key	get_subaddress_spend_public_key (const cryptonote::subaddress_index &index) const

std::vector< crypto::public_key >	get_subaddress_spend_public_keys (uint32_t account, uint32_t begin, uint32_t end) const

std::string	get_subaddress_as_str (const cryptonote::subaddress_index &index) const

std::string	get_address_as_str () const

std::string	get_integrated_address_as_str (const crypto::hash8 &payment_id) const

void	add_subaddress_account (const std::string &label, const bool update_account_tags=true)

size_t	get_num_subaddress_accounts () const

size_t	get_num_subaddresses (uint32_t index_major) const

void	add_subaddress (uint32_t index_major, const std::string &label)

void	expand_subaddresses (const cryptonote::subaddress_index &index, const bool udpate_account_tags=true)

std::string	get_subaddress_label (const cryptonote::subaddress_index &index) const

void	set_subaddress_label (const cryptonote::subaddress_index &index, const std::string &label)

void	set_subaddress_lookahead (size_t major, size_t minor)

std::pair< size_t, size_t >	get_subaddress_lookahead () const

void	account_major_offset (uint32_t offset)

uint32_t	account_major_offset () const

bool	is_deprecated () const
	Tells if the wallet file is deprecated. More...

void	refresh (bool trusted_daemon)

void	refresh (bool trusted_daemon, uint64_t start_height, uint64_t &blocks_fetched)

void	refresh (bool trusted_daemon, uint64_t start_height, uint64_t &blocks_fetched, bool &received_etn, bool check_pool=true)

bool	refresh (bool trusted_daemon, uint64_t &blocks_fetched, bool &received_etn, bool &ok)

void	set_refresh_type (RefreshType refresh_type)

RefreshType	get_refresh_type () const

cryptonote::network_type	nettype () const

bool	watch_only () const

bool	multisig (bool ready=NULL, uint32_t threshold=NULL, uint32_t *total=NULL) const

bool	has_multisig_partial_key_images () const

bool	has_unknown_key_images () const

bool	get_multisig_seed (epee::wipeable_string &seed, const epee::wipeable_string &passphrase=std::string(), bool raw=true) const

bool	key_on_device () const

hw::device::device_type	get_device_type () const

bool	reconnect_device ()

uint64_t	balance (uint32_t subaddr_index_major, bool public_blockchain) const

uint64_t	unlocked_balance (uint32_t subaddr_index_major, bool public_blockchain, uint64_t *blocks_to_unlock=NULL) const

std::map< uint32_t, uint64_t >	balance_per_subaddress (uint32_t subaddr_index_major, bool public_blockchain=false) const

std::map< uint32_t, std::pair< uint64_t, uint64_t > >	unlocked_balance_per_subaddress (uint32_t subaddr_index_major, bool public_blockchain=false) const

uint64_t	balance_all (bool public_blockchain) const

uint64_t	unlocked_balance_all (bool public_blockchain, uint64_t *blocks_to_unlock=NULL) const

template<typename T >
void	transfer_selected (const std::vector< cryptonote::tx_destination_entry > &dsts, const std::vector< size_t > &selected_transfers, size_t fake_outputs_count, std::vector< std::vector< tools::wallet2::get_outs_entry >> &outs, uint64_t unlock_time, uint64_t fee, const std::vector< uint8_t > &extra, T destination_split_strategy, const tx_dust_policy &dust_policy, cryptonote::transaction &tx, pending_tx &ptx)

void	commit_tx (pending_tx &ptx_vector)

void	commit_tx (std::vector< pending_tx > &ptx_vector)

bool	save_tx (const std::vector< pending_tx > &ptx_vector, const std::string &filename) const

std::string	dump_tx_to_str (const std::vector< pending_tx > &ptx_vector) const

std::string	save_multisig_tx (multisig_tx_set txs)

bool	save_multisig_tx (const multisig_tx_set &txs, const std::string &filename)

std::string	save_multisig_tx (const std::vector< pending_tx > &ptx_vector)

bool	save_multisig_tx (const std::vector< pending_tx > &ptx_vector, const std::string &filename)

multisig_tx_set	make_multisig_tx_set (const std::vector< pending_tx > &ptx_vector) const

bool	sign_tx (const std::string &unsigned_filename, const std::string &signed_filename, std::vector< wallet2::pending_tx > &ptx, std::function< bool(const unsigned_tx_set &)> accept_func=NULL, bool export_raw=false)

bool	sign_tx (unsigned_tx_set &exported_txs, const std::string &signed_filename, std::vector< wallet2::pending_tx > &ptx, bool export_raw=false)

bool	sign_tx (unsigned_tx_set &exported_txs, std::vector< wallet2::pending_tx > &ptx, signed_tx_set &signed_txs)

std::string	sign_tx_dump_to_str (unsigned_tx_set &exported_txs, std::vector< wallet2::pending_tx > &ptx, signed_tx_set &signed_txes)

bool	load_unsigned_tx (const std::string &unsigned_filename, unsigned_tx_set &exported_txs) const

bool	parse_unsigned_tx_from_str (const std::string &unsigned_tx_st, unsigned_tx_set &exported_txs) const

bool	load_tx (const std::string &signed_filename, std::vector< tools::wallet2::pending_tx > &ptx, std::function< bool(const signed_tx_set &)> accept_func=NULL)

bool	parse_tx_from_str (const std::string &signed_tx_st, std::vector< tools::wallet2::pending_tx > &ptx, std::function< bool(const signed_tx_set &)> accept_func)

std::vector< wallet2::pending_tx >	create_transactions_2 (std::vector< cryptonote::tx_destination_entry > dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector< uint8_t > &extra, uint32_t subaddr_account, std::set< uint32_t > subaddr_indices)

std::vector< wallet2::pending_tx >	create_transactions_all (uint64_t below, const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector< uint8_t > &extra, uint32_t subaddr_account, std::set< uint32_t > subaddr_indices, const bool migrate=false)

std::vector< wallet2::pending_tx >	create_transactions_single (const crypto::key_image &ki, const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector< uint8_t > &extra)

std::vector< wallet2::pending_tx >	create_transactions_from (const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, std::vector< size_t > unused_transfers_indices, std::vector< size_t > unused_dust_indices, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector< uint8_t > &extra, const uint8_t tx_version)

bool	sanity_check (const std::vector< wallet2::pending_tx > &ptx_vector, std::vector< cryptonote::tx_destination_entry > dsts) const

void	cold_tx_aux_import (const std::vector< pending_tx > &ptx, const std::vector< std::string > &tx_device_aux)

void	cold_sign_tx (const std::vector< pending_tx > &ptx_vector, signed_tx_set &exported_txs, std::vector< cryptonote::address_parse_info > &dsts_info, std::vector< std::string > &tx_device_aux)

uint64_t	cold_key_image_sync (uint64_t &spent, uint64_t &unspent)

bool	parse_multisig_tx_from_str (std::string multisig_tx_st, multisig_tx_set &exported_txs) const

bool	load_multisig_tx (cryptonote::blobdata blob, multisig_tx_set &exported_txs, std::function< bool(const multisig_tx_set &)> accept_func=NULL)

bool	load_multisig_tx_from_file (const std::string &filename, multisig_tx_set &exported_txs, std::function< bool(const multisig_tx_set &)> accept_func=NULL)

bool	sign_multisig_tx_from_file (const std::string &filename, std::vector< crypto::hash > &txids, std::function< bool(const multisig_tx_set &)> accept_func)

bool	sign_multisig_tx (multisig_tx_set &exported_txs, std::vector< crypto::hash > &txids)

bool	sign_multisig_tx_to_file (multisig_tx_set &exported_txs, const std::string &filename, std::vector< crypto::hash > &txids)

std::vector< pending_tx >	create_unmixable_sweep_transactions ()

void	discard_unmixable_outputs ()

bool	check_connection (uint32_t version=NULL, bool ssl=NULL, uint32_t timeout=200000)

void	get_transfers (wallet2::transfer_container &incoming_transfers) const

void	get_payments (const crypto::hash &payment_id, std::list< wallet2::payment_details > &payments, uint64_t min_height=0, const boost::optional< uint32_t > &subaddr_account=boost::none, const std::set< uint32_t > &subaddr_indices={}) const

void	get_payments (std::list< std::pair< crypto::hash, wallet2::payment_details >> &payments, uint64_t min_height, uint64_t max_height=(uint64_t) -1, const boost::optional< uint32_t > &subaddr_account=boost::none, const std::set< uint32_t > &subaddr_indices={}) const

void	get_payments_out (std::list< std::pair< crypto::hash, wallet2::confirmed_transfer_details >> &confirmed_payments, uint64_t min_height, uint64_t max_height=(uint64_t) -1, const boost::optional< uint32_t > &subaddr_account=boost::none, const std::set< uint32_t > &subaddr_indices={}) const

void	get_payments_out_migration (std::list< std::pair< crypto::hash, wallet2::confirmed_transfer_details >> &confirmed_payments, uint64_t min_height, uint64_t max_height=(uint64_t) -1, const boost::optional< uint32_t > &subaddr_account=boost::none, const std::set< uint32_t > &subaddr_indices={}) const

void	get_unconfirmed_payments_out (std::list< std::pair< crypto::hash, wallet2::unconfirmed_transfer_details >> &unconfirmed_payments, const boost::optional< uint32_t > &subaddr_account=boost::none, const std::set< uint32_t > &subaddr_indices={}) const

void	get_unconfirmed_payments (std::list< std::pair< crypto::hash, wallet2::pool_payment_details >> &unconfirmed_payments, const boost::optional< uint32_t > &subaddr_account=boost::none, const std::set< uint32_t > &subaddr_indices={}) const

uint64_t	get_blockchain_current_height () const

bool	synced_to_v10 () const

bool	public_transactions_required () const

void	rescan_spent ()

void	rescan_blockchain (bool hard, bool refresh=true, bool keep_key_images=false)

bool	is_transfer_unlocked (const transfer_details &td) const

bool	is_transfer_unlocked (uint64_t unlock_time, uint64_t block_height) const

uint64_t	get_last_block_reward () const

uint64_t	get_device_last_key_image_sync () const

template<class t_archive >
void	serialize (t_archive &a, const unsigned int ver)

bool	always_confirm_transfers () const

void	always_confirm_transfers (bool always)

bool	print_ring_members () const

void	print_ring_members (bool value)

bool	store_tx_info () const

void	store_tx_info (bool store)

uint32_t	default_mixin () const

void	default_mixin (uint32_t m)

uint32_t	get_default_priority () const

void	set_default_priority (uint32_t p)

bool	auto_refresh () const

void	auto_refresh (bool r)

bool	confirm_missing_payment_id () const

void	confirm_missing_payment_id (bool always)

AskPasswordType	ask_password () const

void	ask_password (AskPasswordType ask)

void	set_min_output_count (uint32_t count)

uint32_t	get_min_output_count () const

void	set_min_output_value (uint64_t value)

uint64_t	get_min_output_value () const

void	merge_destinations (bool merge)

bool	merge_destinations () const

bool	confirm_backlog () const

void	confirm_backlog (bool always)

void	set_confirm_backlog_threshold (uint32_t threshold)

uint32_t	get_confirm_backlog_threshold () const

bool	confirm_export_overwrite () const

void	confirm_export_overwrite (bool always)

bool	auto_low_priority () const

void	auto_low_priority (bool value)

bool	segregate_pre_fork_outputs () const

void	segregate_pre_fork_outputs (bool value)

bool	key_reuse_mitigation2 () const

void	key_reuse_mitigation2 (bool value)

uint64_t	segregation_height () const

void	segregation_height (uint64_t height)

bool	ignore_fractional_outputs () const

void	ignore_fractional_outputs (bool value)

bool	confirm_non_default_ring_size () const

void	confirm_non_default_ring_size (bool always)

bool	track_uses () const

void	track_uses (bool value)

BackgroundMiningSetupType	setup_background_mining () const

void	setup_background_mining (BackgroundMiningSetupType value)

const std::string &	device_name () const

void	device_name (const std::string &device_name)

const std::string &	device_derivation_path () const

void	device_derivation_path (const std::string &device_derivation_path)

bool	get_tx_key_cached (const crypto::hash &txid, crypto::secret_key &tx_key, std::vector< crypto::secret_key > &additional_tx_keys) const

void	set_tx_key (const crypto::hash &txid, const crypto::secret_key &tx_key, const std::vector< crypto::secret_key > &additional_tx_keys)

bool	get_tx_key (const crypto::hash &txid, crypto::secret_key &tx_key, std::vector< crypto::secret_key > &additional_tx_keys)

void	check_tx_key (const crypto::hash &txid, const crypto::secret_key &tx_key, const std::vector< crypto::secret_key > &additional_tx_keys, const cryptonote::account_public_address &address, uint64_t &received, bool &in_pool, uint64_t &confirmations)

void	check_tx_key_helper (const crypto::hash &txid, const crypto::key_derivation &derivation, const std::vector< crypto::key_derivation > &additional_derivations, const cryptonote::account_public_address &address, uint64_t &received, bool &in_pool, uint64_t &confirmations)

void	check_tx_key_helper (const cryptonote::transaction &tx, const crypto::key_derivation &derivation, const std::vector< crypto::key_derivation > &additional_derivations, const cryptonote::account_public_address &address, uint64_t &received) const

std::string	get_tx_proof (const crypto::hash &txid, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message)

std::string	get_tx_proof (const cryptonote::transaction &tx, const crypto::secret_key &tx_key, const std::vector< crypto::secret_key > &additional_tx_keys, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message) const

bool	check_tx_proof (const crypto::hash &txid, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message, const std::string &sig_str, uint64_t &received, bool &in_pool, uint64_t &confirmations)

bool	check_tx_proof (const cryptonote::transaction &tx, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message, const std::string &sig_str, uint64_t &received) const

std::string	get_spend_proof (const crypto::hash &txid, const std::string &message)

bool	check_spend_proof (const crypto::hash &txid, const std::string &message, const std::string &sig_str)

std::string	get_reserve_proof (const boost::optional< std::pair< uint32_t, uint64_t >> &account_minreserve, const std::string &message)
	Generates a proof that proves the reserve of unspent funds. More...

bool	check_reserve_proof (const cryptonote::account_public_address &address, const std::string &message, const std::string &sig_str, uint64_t &total, uint64_t &spent)
	Verifies a proof of reserve. More...

std::vector< address_book_row >	get_address_book () const
	GUI Address book get/store. More...

bool	add_address_book_row (const cryptonote::account_public_address &address, const crypto::hash &payment_id, const std::string &description, bool is_subaddress)

bool	delete_address_book_row (std::size_t row_id)

uint64_t	get_num_rct_outputs ()

size_t	get_num_transfer_details () const

const transfer_details &	get_transfer_details (size_t idx) const

void	get_hard_fork_info (uint8_t version, uint64_t &earliest_height) const

bool	use_fork_rules (uint8_t version, int64_t early_blocks=0) const

int	get_fee_algorithm () const

std::string	get_wallet_file () const

std::string	get_keys_file () const

std::string	get_daemon_address () const

const boost::optional< epee::net_utils::http::login > &	get_daemon_login () const

uint64_t	get_daemon_blockchain_height (std::string &err) const

uint64_t	get_daemon_blockchain_target_height (std::string &err)

uint64_t	get_approximate_blockchain_height () const
	Calculates the approximate blockchain height from current date/time. More...

uint64_t	estimate_blockchain_height ()

std::vector< size_t >	select_available_outputs_from_histogram (uint64_t count, bool atleast, bool unlocked, bool allow_rct)

std::vector< size_t >	select_available_outputs (const std::function< bool(const transfer_details &td)> &f) const

std::vector< size_t >	select_available_unmixable_outputs ()

std::vector< size_t >	select_available_mixable_outputs ()

size_t	pop_best_value_from (const transfer_container &transfers, std::vector< size_t > &unused_dust_indices, const std::vector< size_t > &selected_transfers, bool smallest=false) const

size_t	pop_best_value (std::vector< size_t > &unused_dust_indices, const std::vector< size_t > &selected_transfers, bool smallest=false) const

void	set_tx_note (const crypto::hash &txid, const std::string &note)

std::string	get_tx_note (const crypto::hash &txid) const

void	set_tx_device_aux (const crypto::hash &txid, const std::string &aux)

std::string	get_tx_device_aux (const crypto::hash &txid) const

void	set_description (const std::string &description)

std::string	get_description () const

const std::pair< std::map< std::string, std::string >, std::vector< std::string > > &	get_account_tags ()
	Get the list of registered account tags. More...

void	set_account_tag (const std::set< uint32_t > &account_indices, const std::string &tag)
	Set a tag to the given accounts. More...

void	set_account_tag_description (const std::string &tag, const std::string &description)
	Set the label of the given tag. More...

std::string	sign (const std::string &data) const

bool	verify (const std::string &data, const cryptonote::account_public_address &address, const std::string &signature) const

std::string	sign_multisig_participant (const std::string &data) const
	sign_multisig_participant signs given message with the multisig public signer key More...

bool	verify_with_public_key (const std::string &data, const crypto::public_key &public_key, const std::string &signature) const
	verify_with_public_key verifies message was signed with given public key More...

std::pair< size_t, std::vector< tools::wallet2::transfer_details > >	export_outputs (bool all=false) const

std::string	export_outputs_to_str (bool all=false) const

size_t	import_outputs (const std::pair< size_t, std::vector< tools::wallet2::transfer_details >> &outputs)

size_t	import_outputs_from_str (const std::string &outputs_st)

payment_container	export_payments () const

void	import_payments (const payment_container &payments)

void	import_payments_out (const std::list< std::pair< crypto::hash, wallet2::confirmed_transfer_details >> &confirmed_payments)

std::tuple< size_t, crypto::hash, std::vector< crypto::hash > >	export_blockchain () const

void	import_blockchain (const std::tuple< size_t, crypto::hash, std::vector< crypto::hash >> &bc)

bool	export_key_images (const std::string &filename) const

std::pair< size_t, std::vector< std::pair< crypto::key_image, crypto::signature > > >	export_key_images (bool all=false) const

uint64_t	import_key_images (const std::vector< std::pair< crypto::key_image, crypto::signature >> &signed_key_images, size_t offset, uint64_t &spent, uint64_t &unspent, bool check_spent=true)

uint64_t	import_key_images (const std::string &filename, uint64_t &spent, uint64_t &unspent)

bool	import_key_images (std::vector< crypto::key_image > key_images, size_t offset=0, boost::optional< std::unordered_set< size_t >> selected_transfers=boost::none)

bool	import_key_images (signed_tx_set &signed_tx, size_t offset=0, bool only_selected_transfers=false)

crypto::public_key	get_tx_pub_key_from_received_outs (const tools::wallet2::transfer_details &td) const

void	update_pool_state (bool refreshed=false)

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

std::string	encrypt (const char *plaintext, size_t len, const crypto::secret_key &skey, bool authenticated=true) const

std::string	encrypt (const epee::span< char > &span, const crypto::secret_key &skey, bool authenticated=true) const

std::string	encrypt (const std::string &plaintext, const crypto::secret_key &skey, bool authenticated=true) const

std::string	encrypt (const epee::wipeable_string &plaintext, const crypto::secret_key &skey, bool authenticated=true) const

std::string	encrypt_with_view_secret_key (const std::string &plaintext, bool authenticated=true) const

template<typename T = std::string>
T	decrypt (const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated=true) const

std::string	decrypt_with_view_secret_key (const std::string &ciphertext, bool authenticated=true) const

std::string	make_uri (const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const

bool	parse_uri (const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector< std::string > &unknown_parameters, std::string &error)

uint64_t	get_blockchain_height_by_date (uint16_t year, uint8_t month, uint8_t day)

bool	is_synced () const

std::vector< std::pair< uint64_t, uint64_t > >	estimate_backlog (const std::vector< std::pair< double, double >> &fee_levels)

std::vector< std::pair< uint64_t, uint64_t > >	estimate_backlog (uint64_t min_tx_weight, uint64_t max_tx_weight, const std::vector< uint64_t > &fees)

uint64_t	get_fee_multiplier (uint32_t priority, int fee_algorithm=-1) const

uint64_t	get_base_fee () const

uint64_t	get_fee_quantization_mask () const

uint64_t	get_min_ring_size () const

uint64_t	get_max_ring_size () const

uint64_t	adjust_mixin (uint64_t mixin) const

uint32_t	adjust_priority (uint32_t priority)

bool	is_unattended () const

void	light_wallet_get_unspent_outs ()

void	light_wallet_get_address_txs ()

bool	light_wallet_get_address_info (tools::COMMAND_RPC_GET_ADDRESS_INFO::response &response)

bool	light_wallet_login (bool &new_address)

bool	light_wallet_import_wallet_request (tools::COMMAND_RPC_IMPORT_WALLET_REQUEST::response &response)

void	light_wallet_get_outs (std::vector< std::vector< get_outs_entry >> &outs, const std::vector< size_t > &selected_transfers, size_t fake_outputs_count)

bool	light_wallet_parse_rct_str (const std::string &rct_string, const crypto::public_key &tx_pub_key, uint64_t internal_output_index, rct::key &decrypted_mask, rct::key &rct_commit, bool decrypt) const

bool	light_wallet_key_image_is_ours (const crypto::key_image &key_image, const crypto::public_key &tx_public_key, uint64_t out_index)

void	set_attribute (const std::string &key, const std::string &value)

std::string	get_attribute (const std::string &key) const

crypto::public_key	get_multisig_signer_public_key (const crypto::secret_key &spend_skey) const

crypto::public_key	get_multisig_signer_public_key () const

crypto::public_key	get_multisig_signing_public_key (size_t idx) const

crypto::public_key	get_multisig_signing_public_key (const crypto::secret_key &skey) const

template<class t_request , class t_response >
bool	invoke_http_json (const boost::string_ref uri, const t_request &req, t_response &res, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref http_method="GET")

template<class t_request , class t_response >
bool	invoke_http_bin (const boost::string_ref uri, const t_request &req, t_response &res, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref http_method="GET")

template<class t_request , class t_response >
bool	invoke_http_json_rpc (const boost::string_ref uri, const std::string &method_name, const t_request &req, t_response &res, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref http_method="GET", const std::string &req_id="0")

bool	set_ring_database (const std::string &filename)

const std::string	get_ring_database () const

bool	get_ring (const crypto::key_image &key_image, std::vector< uint64_t > &outs)

bool	get_rings (const crypto::hash &txid, std::vector< std::pair< crypto::key_image, std::vector< uint64_t >>> &outs)

bool	set_ring (const crypto::key_image &key_image, const std::vector< uint64_t > &outs, bool relative)

bool	unset_ring (const std::vector< crypto::key_image > &key_images)

bool	unset_ring (const crypto::hash &txid)

bool	find_and_save_rings (bool force=true)

bool	blackball_output (const std::pair< uint64_t, uint64_t > &output)

bool	set_blackballed_outputs (const std::vector< std::pair< uint64_t, uint64_t >> &outputs, bool add=false)

bool	unblackball_output (const std::pair< uint64_t, uint64_t > &output)

bool	is_output_blackballed (const std::pair< uint64_t, uint64_t > &output) const

void	freeze (size_t idx)

void	thaw (size_t idx)

bool	frozen (size_t idx) const

void	freeze (const crypto::key_image &ki)

void	thaw (const crypto::key_image &ki)

bool	frozen (const crypto::key_image &ki) const

bool	frozen (const transfer_details &td) const

uint64_t	get_bytes_sent () const

uint64_t	get_bytes_received () const

void	add_checkpoint (uint64_t height, std::string hash)

mms::message_store &	get_message_store ()

const mms::message_store &	get_message_store () const

mms::multisig_wallet_state	get_multisig_wallet_state () const

bool	lock_keys_file ()

bool	unlock_keys_file ()

bool	is_keys_file_locked () const

void	change_password (const std::string &filename, const epee::wipeable_string &original_password, const epee::wipeable_string &new_password)

void	set_tx_notify (const std::shared_ptr< tools::Notify > &notify)

bool	is_tx_spendtime_unlocked (uint64_t unlock_time, uint64_t block_height) const

void	hash_m_transfer (const transfer_details &transfer, crypto::hash &hash) const

uint64_t	hash_m_transfers (int64_t transfer_height, crypto::hash &hash) const

void	finish_rescan_bc_keep_key_images (uint64_t transfer_height, const crypto::hash &hash)

void	enable_dns (bool enable)

void	set_offline (bool offline=true)

Static Public Member Functions
static const char *	tr (const char *str)

static bool	has_testnet_option (const boost::program_options::variables_map &vm)

static bool	has_stagenet_option (const boost::program_options::variables_map &vm)

static std::string	device_name_option (const boost::program_options::variables_map &vm)

static std::string	device_derivation_path_option (const boost::program_options::variables_map &vm)

static void	init_options (boost::program_options::options_description &desc_params)

static std::pair< std::unique_ptr< wallet2 >, password_container >	make_from_json (const boost::program_options::variables_map &vm, bool unattended, const std::string &json_file, const std::function< boost::optional< password_container >(const char *, bool)> &password_prompter)
	Uses stdin and stdout. Returns a wallet2 if no errors. More...

static std::pair< std::unique_ptr< wallet2 >, password_container >	make_from_file (const boost::program_options::variables_map &vm, bool unattended, const std::string &wallet_file, const std::function< boost::optional< password_container >(const char *, bool)> &password_prompter)
	Uses stdin and stdout. Returns a wallet2 and password for `wallet_file` if no errors. More...

static std::pair< std::unique_ptr< wallet2 >, password_container >	make_new (const boost::program_options::variables_map &vm, bool unattended, const std::function< boost::optional< password_container >(const char *, bool)> &password_prompter)
	Uses stdin and stdout. Returns a wallet2 and password for wallet with no file if no errors. More...

static std::unique_ptr< wallet2 >	make_dummy (const boost::program_options::variables_map &vm, bool unattended, const std::function< boost::optional< password_container >(const char *, bool)> &password_prompter)
	Just parses variables. More...

static bool	verify_password (const std::string &keys_file_name, const epee::wipeable_string &password, bool no_spend_key, hw::device &hwdev, uint64_t kdf_rounds)
	verify password for specified wallet keys file. More...

static bool	query_device (hw::device::device_type &device_type, const std::string &keys_file_name, const epee::wipeable_string &password, uint64_t kdf_rounds=1)
	determine the key storage for the specified wallet file More...

static bool	verify_multisig_info (const std::string &data, crypto::secret_key &skey, crypto::public_key &pkey)

static bool	verify_extra_multisig_info (const std::string &data, std::unordered_set< crypto::public_key > &pkeys, crypto::public_key &signer)

static void	wallet_exists (const std::string &file_path, bool &keys_file_exists, bool &wallet_file_exists)
	Check if wallet keys and bin files exist. More...

static std::string	get_human_readable_timestamp (uint64_t ts)
	Check if wallet file path is valid format. More...

static bool	wallet_valid_path_format (const std::string &file_path)

static bool	parse_long_payment_id (const std::string &payment_id_str, crypto::hash &payment_id)

static bool	parse_short_payment_id (const std::string &payment_id_str, crypto::hash8 &payment_id)

static bool	parse_payment_id (const std::string &payment_id_str, crypto::hash &payment_id)

Public Attributes
const char *const	ATTRIBUTE_DESCRIPTION = "wallet2.description"

Static Public Attributes
static constexpr const std::chrono::seconds	rpc_timeout = std::chrono::minutes(3) + std::chrono::seconds(30)

Friends
class	::Serialization_portability_wallet_Test

class	::wallet_accessor_test

class	wallet_keys_unlocker

class	wallet_device_callback

Detailed Description

Definition at line 209 of file wallet2.h.

Member Typedef Documentation

◆ get_outs_entry

typedef std::tuple<uint64_t, crypto::public_key, rct::key> tools::wallet2::get_outs_entry

Definition at line 556 of file wallet2.h.

◆ payment_container

typedef std::unordered_multimap<crypto::hash, payment_details> tools::wallet2::payment_container

Definition at line 444 of file wallet2.h.

◆ transfer_container

typedef std::vector<transfer_details> tools::wallet2::transfer_container

Definition at line 443 of file wallet2.h.

Member Enumeration Documentation

◆ AskPasswordType

enum tools::wallet2::AskPasswordType

Enumerator
AskPasswordNever
AskPasswordOnAction
AskPasswordToDecrypt

Definition at line 225 of file wallet2.h.

                          {
       AskPasswordNever = 0,
       AskPasswordOnAction = 1,
       AskPasswordToDecrypt = 2,
     };

◆ BackgroundMiningSetupType

enum tools::wallet2::BackgroundMiningSetupType

Enumerator
BackgroundMiningMaybe
BackgroundMiningYes
BackgroundMiningNo

Definition at line 231 of file wallet2.h.

                                    {
       BackgroundMiningMaybe = 0,
       BackgroundMiningYes = 1,
       BackgroundMiningNo = 2,
     };

◆ RefreshType

enum tools::wallet2::RefreshType

Enumerator
RefreshFull
RefreshOptimizeCoinbase
RefreshNoCoinbase
RefreshDefault

Definition at line 218 of file wallet2.h.

                      {
       RefreshFull,
       RefreshOptimizeCoinbase,
       RefreshNoCoinbase,
       RefreshDefault = RefreshOptimizeCoinbase,
     };

Constructor & Destructor Documentation

◆ wallet2()

tools::wallet2::wallet2	(	cryptonote::network_type	nettype = `cryptonote::MAINNET`,
		uint64_t	kdf_rounds = `1`,
		bool	unattended = `false`
	)

Definition at line 1101 of file wallet2.cpp.

                                                                           :
   m_multisig_rescan_info(NULL),
   m_multisig_rescan_k(NULL),
   m_upper_transaction_weight_limit(0),
   m_run(true),
   m_callback(0),
   m_trusted_daemon(false),
   m_nettype(nettype),
   m_multisig_rounds_passed(0),
   m_always_confirm_transfers(true),
   m_print_ring_members(false),
   m_store_tx_info(true),
   m_default_mixin(0),
   m_default_priority(0),
   m_refresh_type(RefreshOptimizeCoinbase),
   m_auto_refresh(true),
   m_first_refresh_done(false),
   m_refresh_from_block_height(0),
   m_explicit_refresh_from_block_height(true),
   m_confirm_missing_payment_id(true),
   m_confirm_non_default_ring_size(true),
   m_ask_password(AskPasswordOnAction),
   m_min_output_count(0),
   m_min_output_value(0),
   m_merge_destinations(false),
   m_confirm_backlog(true),
   m_confirm_backlog_threshold(0),
   m_confirm_export_overwrite(true),
   m_auto_low_priority(true),
   m_segregate_pre_fork_outputs(true),
   m_key_reuse_mitigation2(true),
   m_segregation_height(0),
   m_ignore_fractional_outputs(true),
   m_track_uses(false),
   m_setup_background_mining(BackgroundMiningMaybe),
   m_is_initialized(false),
   m_kdf_rounds(kdf_rounds),
   is_old_file_format(false),
   m_watch_only(false),
   m_multisig(false),
   m_multisig_threshold(0),
   m_node_rpc_proxy(m_http_client, m_daemon_rpc_mutex),
   m_account_public_address{crypto::null_pkey, crypto::null_pkey},
   m_subaddress_lookahead_major(SUBADDRESS_LOOKAHEAD_MAJOR),
   m_subaddress_lookahead_minor(SUBADDRESS_LOOKAHEAD_MINOR),
   m_light_wallet(false),
   m_light_wallet_scanned_block_height(0),
   m_light_wallet_blockchain_height(0),
   m_light_wallet_connected(false),
   m_light_wallet_balance(0),
   m_light_wallet_unlocked_balance(0),
   m_original_keys_available(false),
   m_message_store(),
   m_key_device_type(hw::device::device_type::SOFTWARE),
   m_ring_history_saved(false),
   m_ringdb(),
   m_last_block_reward(0),
   m_encrypt_keys_after_refresh(boost::none),
   m_unattended(unattended),
   m_devices_registered(false),
   m_device_last_key_image_sync(0),
   m_use_dns(true),
   m_offline(false),
   m_account_major_offset(0)
 {
 }

◆ ~wallet2()

tools::wallet2::~wallet2 ( )

Definition at line 1168 of file wallet2.cpp.

1169 {

1170 }

Member Function Documentation

◆ account_major_offset() [1/2]

uint32_t tools::wallet2::account_major_offset ( ) const

inline

Definition at line 805 of file wallet2.h.

805 {return m_account_major_offset;}

◆ account_major_offset() [2/2]

void tools::wallet2::account_major_offset ( uint32_t offset )

inline

Definition at line 804 of file wallet2.h.

804 {m_account_major_offset = offset;}

◆ add_address_book_row()

bool tools::wallet2::add_address_book_row	(	const cryptonote::account_public_address &	address,
		const crypto::hash &	payment_id,
		const std::string &	description,
		bool	is_subaddress
	)

Definition at line 3434 of file wallet2.cpp.

 {
   wallet2::address_book_row a;
   a.m_address = address;
   a.m_payment_id = payment_id;
   a.m_description = description;
   a.m_is_subaddress = is_subaddress;
   
   auto old_size = m_address_book.size();
   m_address_book.push_back(a);
   if(m_address_book.size() == old_size+1)
     return true;
   return false;
 }

◆ add_checkpoint()

void tools::wallet2::add_checkpoint	(	uint64_t	height,
		std::string	hash
	)

Definition at line 13546 of file wallet2.cpp.

                                                            {
     m_checkpoints.add_checkpoint(height, hash);
 }

◆ add_subaddress()

void tools::wallet2::add_subaddress	(	uint32_t	index_major,
		const std::string &	label
	)

Definition at line 1469 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(index_major >= m_subaddress_labels.size(), error::account_index_outofbound);
   uint32_t index_minor = (uint32_t)get_num_subaddresses(index_major);
   expand_subaddresses({index_major, index_minor});
   m_subaddress_labels[index_major][index_minor] = label;
 }

Here is the call graph for this function:

◆ add_subaddress_account()

void tools::wallet2::add_subaddress_account	(	const std::string &	label,
		const bool	update_account_tags = `true`
	)

Definition at line 1462 of file wallet2.cpp.

 {
   uint32_t index_major = (uint32_t)get_num_subaddress_accounts();
   expand_subaddresses({index_major, 0}, update_account_tags);
   m_subaddress_labels[index_major][0] = label;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ adjust_mixin()

uint64_t tools::wallet2::adjust_mixin ( uint64_t mixin ) const

Definition at line 7653 of file wallet2.cpp.

 {
   const uint64_t min_ring_size = get_min_ring_size();
   if (mixin + 1 < min_ring_size)
   {
     MWARNING("Requested ring size " << (mixin + 1) << " too low, using " << min_ring_size);
     mixin = min_ring_size-1;
   }
   const uint64_t max_ring_size = get_max_ring_size();
   if (max_ring_size && mixin + 1 > max_ring_size)
   {
     MWARNING("Requested ring size " << (mixin + 1) << " too high, using " << max_ring_size);
     mixin = max_ring_size-1;
   }
   return mixin;
 }

◆ adjust_priority()

uint32_t tools::wallet2::adjust_priority ( uint32_t priority )

Definition at line 7670 of file wallet2.cpp.

 {
   if (priority == 0 && m_default_priority == 0 && auto_low_priority())
   {
     try
     {
       // check if there's a backlog in the tx pool
       const bool use_per_byte_fee = use_fork_rules(HF_VERSION_PER_BYTE_FEE, 0);
       const uint64_t base_fee = get_base_fee();
       const uint64_t fee_multiplier = get_fee_multiplier(1);
       const double fee_level = fee_multiplier * base_fee * (use_per_byte_fee ? 1 : (12/(double)13 / (double)1024));
       const std::vector<std::pair<uint64_t, uint64_t>> blocks = estimate_backlog({std::make_pair(fee_level, fee_level)});
       if (blocks.size() != 1)
       {
         MERROR("Bad estimated backlog array size");
         return priority;
       }
       else if (blocks[0].first > 0)
       {
         MINFO("We don't use the low priority because there's a backlog in the tx pool.");
         return priority;
       }
  
       // get the current full reward zone
       uint64_t block_weight_limit = 0;
       const auto result = m_node_rpc_proxy.get_block_weight_limit(block_weight_limit);
       throw_on_rpc_response_error(result, "get_info");
       const uint64_t full_reward_zone = block_weight_limit / 2;
  
       // get the last N block headers and sum the block sizes
       const size_t N = 10;
       if (m_blockchain.size() < N)
       {
         MERROR("The blockchain is too short");
         return priority;
       }
       cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request getbh_req = AUTO_VAL_INIT(getbh_req);
       cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::response getbh_res = AUTO_VAL_INIT(getbh_res);
       m_daemon_rpc_mutex.lock();
       getbh_req.start_height = m_blockchain.size() - N;
       getbh_req.end_height = m_blockchain.size() - 1;
       bool r = invoke_http_json_rpc("/json_rpc", "getblockheadersrange", getbh_req, getbh_res, rpc_timeout);
       m_daemon_rpc_mutex.unlock();
       THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "getblockheadersrange");
       THROW_WALLET_EXCEPTION_IF(getbh_res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getblockheadersrange");
       THROW_WALLET_EXCEPTION_IF(getbh_res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, get_rpc_status(getbh_res.status));
       if (getbh_res.headers.size() != N)
       {
         MERROR("Bad blockheaders size");
         return priority;
       }
       size_t block_weight_sum = 0;
       for (const cryptonote::block_header_response &i : getbh_res.headers)
       {
         block_weight_sum += i.block_weight;
       }
  
       // estimate how 'full' the last N blocks are
       const size_t P = 100 * block_weight_sum / (N * full_reward_zone);
       MINFO((boost::format("The last %d blocks fill roughly %d%% of the full reward zone.") % N % P).str());
       if (P > 80)
       {
         MINFO("We don't use the low priority because recent blocks are quite full.");
         return priority;
       }
       MINFO("We'll use the low priority because probably it's safe to do so.");
       return 1;
     }
     catch (const std::exception &e)
     {
       MERROR(e.what());
     }
   }
   return priority;
 }

◆ always_confirm_transfers() [1/2]

bool tools::wallet2::always_confirm_transfers ( ) const

inline

Definition at line 1057 of file wallet2.h.

1057 { return m_always_confirm_transfers; }

◆ always_confirm_transfers() [2/2]

void tools::wallet2::always_confirm_transfers ( bool always )

inline

Definition at line 1058 of file wallet2.h.

1058 { m_always_confirm_transfers = always; }

◆ ask_password() [1/2]

AskPasswordType tools::wallet2::ask_password ( ) const

inline

Definition at line 1071 of file wallet2.h.

1071 { return m_ask_password; }

Here is the caller graph for this function:

◆ ask_password() [2/2]

void tools::wallet2::ask_password ( AskPasswordType ask )

inline

Definition at line 1072 of file wallet2.h.

1072 { m_ask_password = ask; }

◆ auto_low_priority() [1/2]

bool tools::wallet2::auto_low_priority ( ) const

inline

Definition at line 1085 of file wallet2.h.

1085 { return m_auto_low_priority; }

◆ auto_low_priority() [2/2]

void tools::wallet2::auto_low_priority ( bool value )

inline

Definition at line 1086 of file wallet2.h.

1086 { m_auto_low_priority = value; }

value

const GenericPointer< typename T::ValueType > T2 value

Definition: pointer.h:1225

◆ auto_refresh() [1/2]

bool tools::wallet2::auto_refresh ( ) const

inline

Definition at line 1067 of file wallet2.h.

1067 { return m_auto_refresh; }

◆ auto_refresh() [2/2]

void tools::wallet2::auto_refresh ( bool r )

inline

Definition at line 1068 of file wallet2.h.

1068 { m_auto_refresh = r; }

◆ balance()

uint64_t tools::wallet2::balance	(	uint32_t	subaddr_index_major,
		bool	public_blockchain
	)		const

Definition at line 6052 of file wallet2.cpp.

 {
   uint64_t amount = 0;
   if(m_light_wallet)
     return m_light_wallet_unlocked_balance;
   for (const auto& i : balance_per_subaddress(index_major, public_blockchain))
     amount += i.second;
   return amount;
 }

Here is the caller graph for this function:

◆ balance_all()

uint64_t tools::wallet2::balance_all ( bool public_blockchain ) const

Definition at line 6182 of file wallet2.cpp.

 {
   uint64_t r = 0;
   for (uint32_t index_major = 0; index_major < get_num_subaddress_accounts(); ++index_major)
     r += balance(index_major, public_blockchain);
   return r;
 }

◆ balance_per_subaddress()

std::map< uint32_t, uint64_t > tools::wallet2::balance_per_subaddress	(	uint32_t	subaddr_index_major,
		bool	public_blockchain = `false`
	)		const

Definition at line 6078 of file wallet2.cpp.

 {
   std::map<uint32_t, uint64_t> amount_per_subaddr;
   for (const auto& td: m_transfers)
   {
       if((public_blockchain && td.m_tx.version == 1) || (!public_blockchain && td.m_tx.version > 1))
           continue;
  
       if (td.m_subaddr_index.major == index_major && !td.m_spent && !td.m_frozen)
     {
       auto found = amount_per_subaddr.find(td.m_subaddr_index.minor);
       if (found == amount_per_subaddr.end())
         amount_per_subaddr[td.m_subaddr_index.minor] = td.amount();
       else
         found->second += td.amount();
     }
   }
   for (const auto& utx: m_unconfirmed_txs) {
       if ((public_blockchain && utx.second.m_tx.version == 1) || (!public_blockchain && utx.second.m_tx.version > 1))
           continue;
  
       if (utx.second.m_state != wallet2::unconfirmed_transfer_details::failed) {
           //HANDLE LOOPBACK OUTS INCLUDING CHANGE
           if(utx.second.m_tx.version > 1){
               for (const cryptonote::tx_out &out : utx.second.m_tx.vout) {
                   if (out.target.type() == typeid(txout_to_key_public)) {
                       // check whether this out is to one of our subaddresses
                       auto target = boost::get<cryptonote::txout_to_key_public>(out.target);
                       auto subaddr_found = m_subaddresses.find(target.address.m_spend_public_key);
                       // if this out is to us
                       // and the view key part of the destination matches that of our our subaddress,
                       // and the major index of this subaddress corresponds to the current account we're getting balance for,
                       // then add amount to balance
                       if (subaddr_found != m_subaddresses.end() && get_subaddress(subaddr_found->second).m_view_public_key == target.address.m_view_public_key && subaddr_found->second.major == index_major) {
                           auto found = amount_per_subaddr.find(subaddr_found->second.minor);
                           if (found == amount_per_subaddr.end())
                               amount_per_subaddr[subaddr_found->second.minor] = out.amount;
                           else
                               found->second += out.amount;
                       } else {
                           continue;
                       }
                   }
               }
           }
           // CHANGE HANDLING FOR V1 TX
           // (NB LOOPBACK OUTS APART FROM CHANGE AREN'T FACTORED INTO BAL WHILST TX IS UNCONFIRMED
           // and there is no need to fix this (monero) issue as we've migrated to a transparent chain)
           if (utx.second.m_tx.version == 1 && utx.second.m_subaddr_account == index_major) {
               // all changes go to 0-th subaddress (in the current subaddress account)
               auto found = amount_per_subaddr.find(0);
               if (found == amount_per_subaddr.end())
                   amount_per_subaddr[0] = utx.second.m_change;
               else
                   found->second += utx.second.m_change;
           }
       }
   }
   return amount_per_subaddr;
 }

◆ blackball_output()

bool tools::wallet2::blackball_output ( const std::pair< uint64_t, uint64_t > & output )

Definition at line 7965 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
   try { return m_ringdb->blackball(output); }
   catch (const std::exception &e) { return false; }
 }

◆ callback() [1/2]

i_wallet2_callback* tools::wallet2::callback ( ) const

inline

Definition at line 756 of file wallet2.h.

756 { return m_callback; }

◆ callback() [2/2]

void tools::wallet2::callback ( i_wallet2_callback * callback )

inline

Definition at line 757 of file wallet2.h.

757 { m_callback = callback; }

tools::wallet2::callback

i_wallet2_callback * callback() const

Definition: wallet2.h:756

Here is the call graph for this function:

Here is the caller graph for this function:

◆ change_password()

void tools::wallet2::change_password	(	const std::string &	filename,
		const epee::wipeable_string &	original_password,
		const epee::wipeable_string &	new_password
	)

Definition at line 4210 of file wallet2.cpp.

 {
   if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
     decrypt_keys(original_password);
   setup_keys(new_password);
   rewrite(filename, new_password);
   if (!filename.empty())
     store();
 }

◆ check_connection()

bool tools::wallet2::check_connection	(	uint32_t *	version = `NULL`,
		bool *	ssl = `NULL`,
		uint32_t	timeout = `200000`
	)

Definition at line 5648 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(!m_is_initialized, error::wallet_not_initialized);
  
   if (m_offline)
   {
     if (version)
       *version = 0;
     if (ssl)
       *ssl = false;
     return false;
   }
  
   // TODO: Add light wallet version check.
   if(m_light_wallet) {
       if (version)
         *version = 0;
       if (ssl)
         *ssl = m_light_wallet_connected; // light wallet is always SSL
       return m_light_wallet_connected;
   }
  
   {
     boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
     if(!m_http_client.is_connected(ssl))
     {
       m_node_rpc_proxy.invalidate();
       if (!m_http_client.connect(std::chrono::milliseconds(timeout)))
         return false;
       if(!m_http_client.is_connected(ssl))
         return false;
     }
   }
  
   if (version)
   {
     cryptonote::COMMAND_RPC_GET_VERSION::request req_t = AUTO_VAL_INIT(req_t);
     cryptonote::COMMAND_RPC_GET_VERSION::response resp_t = AUTO_VAL_INIT(resp_t);
     bool r = invoke_http_json_rpc("/json_rpc", "get_version", req_t, resp_t);
     if(!r) {
       *version = 0;
       return false;
     }
     if (resp_t.status != CORE_RPC_STATUS_OK)
       *version = 0;
     else
       *version = resp_t.version;
   }
  
   return true;
 }

Here is the call graph for this function:

◆ check_reserve_proof()

bool tools::wallet2::check_reserve_proof	(	const cryptonote::account_public_address &	address,
		const std::string &	message,
		const std::string &	sig_str,
		uint64_t &	total,
		uint64_t &	spent
	)

Verifies a proof of reserve.

Parameters

address	The signer's address
message	Challenge message used for signing
sig_str	Signature string
total	[OUT] the sum of funds included in the signature
spent	[OUT] the sum of spent funds included in the signature

Returns: true if the signature verifies correctly

Definition at line 11580 of file wallet2.cpp.

 {
   uint32_t rpc_version;
   THROW_WALLET_EXCEPTION_IF(!check_connection(&rpc_version), error::wallet_internal_error, "Failed to connect to daemon: " + get_daemon_address());
   THROW_WALLET_EXCEPTION_IF(rpc_version < MAKE_CORE_RPC_VERSION(1, 0), error::wallet_internal_error, "Daemon RPC version is too old");
  
   static constexpr char header[] = "ReserveProofV1";
   THROW_WALLET_EXCEPTION_IF(!boost::string_ref{sig_str}.starts_with(header), error::wallet_internal_error,
     "Signature header check error");
  
   std::string sig_decoded;
   THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(std::strlen(header)), sig_decoded), error::wallet_internal_error,
     "Signature decoding error");
  
   std::istringstream iss(sig_decoded);
   boost::archive::portable_binary_iarchive ar(iss);
   std::vector<reserve_proof_entry> proofs;
   std::unordered_map<crypto::public_key, crypto::signature> subaddr_spendkeys;
   ar >> proofs >> subaddr_spendkeys;
  
   THROW_WALLET_EXCEPTION_IF(subaddr_spendkeys.count(address.m_spend_public_key) == 0, error::wallet_internal_error,
     "The given address isn't found in the proof");
  
   // compute signature prefix hash
   std::string prefix_data = message;
   prefix_data.append((const char*)&address, sizeof(cryptonote::account_public_address));
   for (size_t i = 0; i < proofs.size(); ++i)
   {
     prefix_data.append((const char*)&proofs[i].key_image, sizeof(crypto::key_image));
   }
   crypto::hash prefix_hash;
   crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
  
   // fetch txes from daemon
   COMMAND_RPC_GET_TRANSACTIONS::request gettx_req;
   COMMAND_RPC_GET_TRANSACTIONS::response gettx_res;
   for (size_t i = 0; i < proofs.size(); ++i)
     gettx_req.txs_hashes.push_back(epee::string_tools::pod_to_hex(proofs[i].txid));
   gettx_req.decode_as_json = false;
   gettx_req.prune = true;
   m_daemon_rpc_mutex.lock();
   bool ok = invoke_http_json("/gettransactions", gettx_req, gettx_res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!ok || gettx_res.txs.size() != proofs.size(),
     error::wallet_internal_error, "Failed to get transaction from daemon");
  
   // check spent status
   COMMAND_RPC_IS_KEY_IMAGE_SPENT::request kispent_req;
   COMMAND_RPC_IS_KEY_IMAGE_SPENT::response kispent_res;
   for (size_t i = 0; i < proofs.size(); ++i)
     kispent_req.key_images.push_back(epee::string_tools::pod_to_hex(proofs[i].key_image));
   m_daemon_rpc_mutex.lock();
   ok = invoke_http_json("/is_key_image_spent", kispent_req, kispent_res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!ok || kispent_res.spent_status.size() != proofs.size(),
     error::wallet_internal_error, "Failed to get key image spent status from daemon");
  
   total = spent = 0;
   for (size_t i = 0; i < proofs.size(); ++i)
   {
     const reserve_proof_entry& proof = proofs[i];
     THROW_WALLET_EXCEPTION_IF(gettx_res.txs[i].in_pool, error::wallet_internal_error, "Tx is unconfirmed");
  
     cryptonote::transaction tx;
     crypto::hash tx_hash;
     ok = get_pruned_tx(gettx_res.txs[i], tx, tx_hash);
     THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
  
     THROW_WALLET_EXCEPTION_IF(tx_hash != proof.txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
  
     THROW_WALLET_EXCEPTION_IF(proof.index_in_tx >= tx.vout.size(), error::wallet_internal_error, "index_in_tx is out of bound");
  
     const cryptonote::txout_to_key* const out_key = boost::get<cryptonote::txout_to_key>(std::addressof(tx.vout[proof.index_in_tx].target));
     THROW_WALLET_EXCEPTION_IF(!out_key, error::wallet_internal_error, "Output key wasn't found")
  
     // get tx pub key
     const crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
     THROW_WALLET_EXCEPTION_IF(tx_pub_key == crypto::null_pkey, error::wallet_internal_error, "The tx public key isn't found");
     const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
  
     // check singature for shared secret
     ok = crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, proof.shared_secret, proof.shared_secret_sig);
     if (!ok && additional_tx_pub_keys.size() == tx.vout.size())
       ok = crypto::check_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[proof.index_in_tx], boost::none, proof.shared_secret, proof.shared_secret_sig);
     if (!ok)
       return false;
  
     // check signature for key image
     const std::vector<const crypto::public_key*> pubs = { &out_key->key };
     ok = crypto::check_ring_signature(prefix_hash, proof.key_image, &pubs[0], 1, &proof.key_image_sig);
     if (!ok)
       return false;
  
     // check if the address really received the fund
     crypto::key_derivation derivation;
     THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(proof.shared_secret, rct::rct2sk(rct::I), derivation), error::wallet_internal_error, "Failed to generate key derivation");
     crypto::public_key subaddr_spendkey;
     crypto::derive_subaddress_public_key(out_key->key, derivation, proof.index_in_tx, subaddr_spendkey);
     THROW_WALLET_EXCEPTION_IF(subaddr_spendkeys.count(subaddr_spendkey) == 0, error::wallet_internal_error,
       "The address doesn't seem to have received the fund");
  
     // check amount
     uint64_t amount = tx.vout[proof.index_in_tx].amount;
     if (amount == 0)
     {
       // decode rct
       crypto::secret_key shared_secret;
       crypto::derivation_to_scalar(derivation, proof.index_in_tx, shared_secret);
       rct::ecdhTuple ecdh_info = tx.rct_signatures.ecdhInfo[proof.index_in_tx];
       rct::ecdhDecode(ecdh_info, rct::sk2rct(shared_secret), tx.rct_signatures.type == rct::RCTTypeBulletproof2);
       amount = rct::h2d(ecdh_info.amount);
     }
     total += amount;
     if (kispent_res.spent_status[i])
       spent += amount;
   }
  
   // check signatures for all subaddress spend keys
   for (const auto &i : subaddr_spendkeys)
   {
     if (!crypto::check_signature(prefix_hash, i.first, i.second))
       return false;
   }
   return true;
 }

Here is the call graph for this function:

◆ check_spend_proof()

bool tools::wallet2::check_spend_proof	(	const crypto::hash &	txid,
		const std::string &	message,
		const std::string &	sig_str
	)

Definition at line 10953 of file wallet2.cpp.

 {
   const std::string header = "SpendProofV1";
   const size_t header_len = header.size();
   THROW_WALLET_EXCEPTION_IF(sig_str.size() < header_len || sig_str.substr(0, header_len) != header, error::wallet_internal_error,
     "Signature header check error");
  
   // fetch tx from daemon
   COMMAND_RPC_GET_TRANSACTIONS::request req = AUTO_VAL_INIT(req);
   req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
   req.decode_as_json = false;
   req.prune = true;
   COMMAND_RPC_GET_TRANSACTIONS::response res = AUTO_VAL_INIT(res);
   bool r;
   {
     const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex}; 
     r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
   }
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.txs.size() != 1, error::wallet_internal_error,
     "daemon returned wrong response for gettransactions, wrong txs count = " +
     std::to_string(res.txs.size()) + ", expected 1");
  
   cryptonote::transaction tx;
   crypto::hash tx_hash;
   THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(res.txs[0], tx, tx_hash), error::wallet_internal_error, "failed to get tx from daemon");
  
   // check signature size
   size_t num_sigs = 0;
   for(size_t i = 0; i < tx.vin.size(); ++i)
   {
     const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
     if (in_key != nullptr)
       num_sigs += in_key->key_offsets.size();
   }
   std::vector<std::vector<crypto::signature>> signatures = { std::vector<crypto::signature>(1) };
   const size_t sig_len = tools::base58::encode(std::string((const char *)&signatures[0][0], sizeof(crypto::signature))).size();
   if( sig_str.size() != header_len + num_sigs * sig_len ) {
     return false;
   }
  
   // decode base58
   signatures.clear();
   size_t offset = header_len;
   for(size_t i = 0; i < tx.vin.size(); ++i)
   {
     const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
     if (in_key == nullptr)
       continue;
     signatures.resize(signatures.size() + 1);
     signatures.back().resize(in_key->key_offsets.size());
     for (size_t j = 0; j < in_key->key_offsets.size(); ++j)
     {
       std::string sig_decoded;
       THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(offset, sig_len), sig_decoded), error::wallet_internal_error, "Signature decoding error");
       THROW_WALLET_EXCEPTION_IF(sizeof(crypto::signature) != sig_decoded.size(), error::wallet_internal_error, "Signature decoding error");
       memcpy(&signatures.back()[j], sig_decoded.data(), sizeof(crypto::signature));
       offset += sig_len;
     }
   }
  
   // get signature prefix hash
   std::string sig_prefix_data((const char*)&txid, sizeof(crypto::hash));
   sig_prefix_data += message;
   crypto::hash sig_prefix_hash;
   crypto::cn_fast_hash(sig_prefix_data.data(), sig_prefix_data.size(), sig_prefix_hash);
  
   std::vector<std::vector<crypto::signature>>::const_iterator sig_iter = signatures.cbegin();
   for(size_t i = 0; i < tx.vin.size(); ++i)
   {
     const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
     if (in_key == nullptr)
       continue;
  
     // get output pubkeys in the ring
     COMMAND_RPC_GET_OUTPUTS_BIN::request req = AUTO_VAL_INIT(req);
     const std::vector<uint64_t> absolute_offsets = cryptonote::relative_output_offsets_to_absolute(in_key->key_offsets);
     req.outputs.resize(absolute_offsets.size());
     for (size_t j = 0; j < absolute_offsets.size(); ++j)
     {
       req.outputs[j].amount = in_key->amount;
       req.outputs[j].index = absolute_offsets[j];
     }
     COMMAND_RPC_GET_OUTPUTS_BIN::response res = AUTO_VAL_INIT(res);
     bool r;
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex}; 
       r = invoke_http_bin("/get_outs.bin", req, res, rpc_timeout);
     }
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(res.outs.size() != req.outputs.size(), error::wallet_internal_error,
       "daemon returned wrong response for get_outs.bin, wrong amounts count = " +
       std::to_string(res.outs.size()) + ", expected " +  std::to_string(req.outputs.size()));
  
     // copy pointers
     std::vector<const crypto::public_key *> p_output_keys;
     for (const COMMAND_RPC_GET_OUTPUTS_BIN::outkey &out : res.outs)
       p_output_keys.push_back(&out.key);
  
     // check this ring
     if (!crypto::check_ring_signature(sig_prefix_hash, in_key->k_image, p_output_keys, sig_iter->data()))
       return false;
     ++sig_iter;
   }
   THROW_WALLET_EXCEPTION_IF(sig_iter != signatures.cend(), error::wallet_internal_error, "Signature iterator didn't reach the end");
   return true;
 }

Here is the call graph for this function:

◆ check_tx_key()

void tools::wallet2::check_tx_key	(	const crypto::hash &	txid,
		const crypto::secret_key &	tx_key,
		const std::vector< crypto::secret_key > &	additional_tx_keys,
		const cryptonote::account_public_address &	address,
		uint64_t &	received,
		bool &	in_pool,
		uint64_t &	confirmations
	)

Definition at line 11066 of file wallet2.cpp.

 {
   crypto::key_derivation derivation;
   THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(address.m_view_public_key, tx_key, derivation), error::wallet_internal_error,
     "Failed to generate key derivation from supplied parameters");
  
   std::vector<crypto::key_derivation> additional_derivations;
   additional_derivations.resize(additional_tx_keys.size());
   for (size_t i = 0; i < additional_tx_keys.size(); ++i)
     THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(address.m_view_public_key, additional_tx_keys[i], additional_derivations[i]), error::wallet_internal_error,
       "Failed to generate key derivation from supplied parameters");
  
   check_tx_key_helper(txid, derivation, additional_derivations, address, received, in_pool, confirmations);
 }

Here is the call graph for this function:

◆ check_tx_key_helper() [1/2]

void tools::wallet2::check_tx_key_helper	(	const crypto::hash &	txid,
		const crypto::key_derivation &	derivation,
		const std::vector< crypto::key_derivation > &	additional_derivations,
		const cryptonote::account_public_address &	address,
		uint64_t &	received,
		bool &	in_pool,
		uint64_t &	confirmations
	)

Definition at line 11113 of file wallet2.cpp.

 {
   COMMAND_RPC_GET_TRANSACTIONS::request req;
   COMMAND_RPC_GET_TRANSACTIONS::response res;
   req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
   req.decode_as_json = false;
   req.prune = true;
   m_daemon_rpc_mutex.lock();
   bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
     error::wallet_internal_error, "Failed to get transaction from daemon");
  
   cryptonote::transaction tx;
   crypto::hash tx_hash;
   if (res.txs.size() == 1)
   {
     ok = get_pruned_tx(res.txs.front(), tx, tx_hash);
     THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
   }
   else
   {
     cryptonote::blobdata tx_data;
     ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
     THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
     THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx),
         error::wallet_internal_error, "Failed to validate transaction from daemon");
     tx_hash = cryptonote::get_transaction_hash(tx);
   }
  
   THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error,
     "Failed to get the right transaction from daemon");
   THROW_WALLET_EXCEPTION_IF(!additional_derivations.empty() && additional_derivations.size() != tx.vout.size(), error::wallet_internal_error,
     "The size of additional derivations is wrong");
  
   check_tx_key_helper(tx, derivation, additional_derivations, address, received);
  
   in_pool = res.txs.front().in_pool;
   confirmations = 0;
   if (!in_pool)
   {
     std::string err;
     uint64_t bc_height = get_daemon_blockchain_height(err);
     if (err.empty())
       confirmations = bc_height - res.txs.front().block_height;
   }
 }

Here is the call graph for this function:

◆ check_tx_key_helper() [2/2]

void tools::wallet2::check_tx_key_helper	(	const cryptonote::transaction &	tx,
		const crypto::key_derivation &	derivation,
		const std::vector< crypto::key_derivation > &	additional_derivations,
		const cryptonote::account_public_address &	address,
		uint64_t &	received
	)		const

Definition at line 11081 of file wallet2.cpp.

 {
   received = 0;
  
   for (size_t n = 0; n < tx.vout.size(); ++n)
   {
     const cryptonote::txout_to_key* const out_key = boost::get<cryptonote::txout_to_key>(std::addressof(tx.vout[n].target));
     if (!out_key)
       continue;
  
     crypto::public_key derived_out_key;
     bool r = crypto::derive_public_key(derivation, n, address.m_spend_public_key, derived_out_key);
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to derive public key");
     bool found = out_key->key == derived_out_key;
     crypto::key_derivation found_derivation = derivation;
     if (!found && !additional_derivations.empty())
     {
       r = crypto::derive_public_key(additional_derivations[n], n, address.m_spend_public_key, derived_out_key);
       THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to derive public key");
       found = out_key->key == derived_out_key;
       found_derivation = additional_derivations[n];
     }
  
     if (found)
     {
       uint64_t amount;
       amount = tx.vout[n].amount;
       received += amount;
     }
   }
 }

Here is the call graph for this function:

◆ check_tx_proof() [1/2]

bool tools::wallet2::check_tx_proof	(	const crypto::hash &	txid,
		const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const std::string &	message,
		const std::string &	sig_str,
		uint64_t &	received,
		bool &	in_pool,
		uint64_t &	confirmations
	)

Definition at line 11317 of file wallet2.cpp.

 {
   // fetch tx pubkey from the daemon
   COMMAND_RPC_GET_TRANSACTIONS::request req;
   COMMAND_RPC_GET_TRANSACTIONS::response res;
   req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
   req.decode_as_json = false;
   req.prune = true;
   m_daemon_rpc_mutex.lock();
   bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
     error::wallet_internal_error, "Failed to get transaction from daemon");
  
   cryptonote::transaction tx;
   crypto::hash tx_hash;
   if (res.txs.size() == 1)
   {
     ok = get_pruned_tx(res.txs.front(), tx, tx_hash);
     THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
   }
   else
   {
     cryptonote::blobdata tx_data;
     ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
     THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
     THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx),
         error::wallet_internal_error, "Failed to validate transaction from daemon");
     tx_hash = cryptonote::get_transaction_hash(tx);
   }
  
   THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
  
   if (!check_tx_proof(tx, address, is_subaddress, message, sig_str, received))
     return false;
  
   in_pool = res.txs.front().in_pool;
   confirmations = 0;
   if (!in_pool)
   {
     std::string err;
     uint64_t bc_height = get_daemon_blockchain_height(err);
     if (err.empty())
       confirmations = bc_height - res.txs.front().block_height;
   }
  
   return true;
 }

Here is the call graph for this function:

◆ check_tx_proof() [2/2]

bool tools::wallet2::check_tx_proof	(	const cryptonote::transaction &	tx,
		const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const std::string &	message,
		const std::string &	sig_str,
		uint64_t &	received
	)		const

Definition at line 11366 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(tx.version == 1, "Tx proofs are for v1 transactions only");
   const bool is_out = sig_str.substr(0, 3) == "Out";
   const std::string header = is_out ? "OutProofV1" : "InProofV1";
   const size_t header_len = header.size();
   THROW_WALLET_EXCEPTION_IF(sig_str.size() < header_len || sig_str.substr(0, header_len) != header, error::wallet_internal_error,
     "Signature header check error");
  
   // decode base58
   std::vector<crypto::public_key> shared_secret(1);
   std::vector<crypto::signature> sig(1);
   const size_t pk_len = tools::base58::encode(std::string((const char *)&shared_secret[0], sizeof(crypto::public_key))).size();
   const size_t sig_len = tools::base58::encode(std::string((const char *)&sig[0], sizeof(crypto::signature))).size();
   const size_t num_sigs = (sig_str.size() - header_len) / (pk_len + sig_len);
   THROW_WALLET_EXCEPTION_IF(sig_str.size() != header_len + num_sigs * (pk_len + sig_len), error::wallet_internal_error,
     "Wrong signature size");
   shared_secret.resize(num_sigs);
   sig.resize(num_sigs);
   for (size_t i = 0; i < num_sigs; ++i)
   {
     std::string pk_decoded;
     std::string sig_decoded;
     const size_t offset = header_len + i * (pk_len + sig_len);
     THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(offset, pk_len), pk_decoded), error::wallet_internal_error,
       "Signature decoding error");
     THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(offset + pk_len, sig_len), sig_decoded), error::wallet_internal_error,
       "Signature decoding error");
     THROW_WALLET_EXCEPTION_IF(sizeof(crypto::public_key) != pk_decoded.size() || sizeof(crypto::signature) != sig_decoded.size(), error::wallet_internal_error,
       "Signature decoding error");
     memcpy(&shared_secret[i], pk_decoded.data(), sizeof(crypto::public_key));
     memcpy(&sig[i], sig_decoded.data(), sizeof(crypto::signature));
   }
  
   crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
   THROW_WALLET_EXCEPTION_IF(tx_pub_key == null_pkey, error::wallet_internal_error, "Tx pubkey was not found");
  
   std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
   THROW_WALLET_EXCEPTION_IF(additional_tx_pub_keys.size() + 1 != num_sigs, error::wallet_internal_error, "Signature size mismatch with additional tx pubkeys");
  
   const crypto::hash txid = cryptonote::get_transaction_hash(tx);
   std::string prefix_data((const char*)&txid, sizeof(crypto::hash));
   prefix_data += message;
   crypto::hash prefix_hash;
   crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
  
   // check signature
   std::vector<int> good_signature(num_sigs, 0);
   if (is_out)
   {
     good_signature[0] = is_subaddress ?
       crypto::check_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, address.m_spend_public_key, shared_secret[0], sig[0]) :
       crypto::check_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, boost::none, shared_secret[0], sig[0]);
  
     for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
     {
       good_signature[i + 1] = is_subaddress ?
         crypto::check_tx_proof(prefix_hash, additional_tx_pub_keys[i], address.m_view_public_key, address.m_spend_public_key, shared_secret[i + 1], sig[i + 1]) :
         crypto::check_tx_proof(prefix_hash, additional_tx_pub_keys[i], address.m_view_public_key, boost::none, shared_secret[i + 1], sig[i + 1]);
     }
   }
   else
   {
     good_signature[0] = is_subaddress ?
       crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, address.m_spend_public_key, shared_secret[0], sig[0]) :
       crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, shared_secret[0], sig[0]);
  
     for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
     {
       good_signature[i + 1] = is_subaddress ?
         crypto::check_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i], address.m_spend_public_key, shared_secret[i + 1], sig[i + 1]) :
         crypto::check_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i], boost::none, shared_secret[i + 1], sig[i + 1]);
     }
   }
  
   if (std::any_of(good_signature.begin(), good_signature.end(), [](int i) { return i > 0; }))
   {
     // obtain key derivation by multiplying scalar 1 to the shared secret
     crypto::key_derivation derivation;
     if (good_signature[0])
       THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[0], rct::rct2sk(rct::I), derivation), error::wallet_internal_error, "Failed to generate key derivation");
  
     std::vector<crypto::key_derivation> additional_derivations(num_sigs - 1);
     for (size_t i = 1; i < num_sigs; ++i)
       if (good_signature[i])
         THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[i], rct::rct2sk(rct::I), additional_derivations[i - 1]), error::wallet_internal_error, "Failed to generate key derivation");
  
     check_tx_key_helper(tx, derivation, additional_derivations, address, received);
     return true;
   }
   return false;
 }

Here is the call graph for this function:

◆ cold_key_image_sync()

uint64_t tools::wallet2::cold_key_image_sync	(	uint64_t &	spent,
		uint64_t &	unspent
	)

Definition at line 10484 of file wallet2.cpp.

                                                                         {
   auto & hwdev = get_account().get_device();
   CHECK_AND_ASSERT_THROW_MES(hwdev.has_ki_cold_sync(), "Device does not support cold ki sync protocol");
  
   auto dev_cold = dynamic_cast<::hw::device_cold*>(&hwdev);
   CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
  
   std::vector<std::pair<crypto::key_image, crypto::signature>> ski;
   hw::wallet_shim wallet_shim;
   setup_shim(&wallet_shim, this);
  
   dev_cold->ki_sync(&wallet_shim, m_transfers, ski);
  
   // Call COMMAND_RPC_IS_KEY_IMAGE_SPENT only if daemon is trusted.
   uint64_t import_res = import_key_images(ski, 0, spent, unspent, is_trusted_daemon());
   m_device_last_key_image_sync = time(NULL);
  
   return import_res;
 }

Here is the call graph for this function:

◆ cold_sign_tx()

void tools::wallet2::cold_sign_tx	(	const std::vector< pending_tx > &	ptx_vector,
		signed_tx_set &	exported_txs,
		std::vector< cryptonote::address_parse_info > &	dsts_info,
		std::vector< std::string > &	tx_device_aux
	)

Definition at line 10455 of file wallet2.cpp.

 {
   auto & hwdev = get_account().get_device();
   if (!hwdev.has_tx_cold_sign()){
     throw std::invalid_argument("Device does not support cold sign protocol");
   }
  
   unsigned_tx_set txs;
   for (auto &tx: ptx_vector)
   {
     txs.txes.push_back(get_construction_data_with_decrypted_short_payment_id(tx, m_account.get_device()));
   }
   txs.transfers = std::make_pair(0, m_transfers);
  
   auto dev_cold = dynamic_cast<::hw::device_cold*>(&hwdev);
   CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
  
   hw::tx_aux_data aux_data;
   hw::wallet_shim wallet_shim;
   setup_shim(&wallet_shim, this);
   aux_data.tx_recipients = dsts_info;
   aux_data.bp_version = use_fork_rules(HF_VERSION_SMALLER_BP, -10) ? 2 : 1;
   dev_cold->tx_sign(&wallet_shim, txs, exported_txs, aux_data);
   tx_device_aux = aux_data.tx_device_aux;
  
   MDEBUG("Signed tx data from hw: " << exported_txs.ptx.size() << " transactions");
   for (auto &c_ptx: exported_txs.ptx) LOG_PRINT_L0(cryptonote::obj_to_json_str(c_ptx.tx));
 }

Here is the call graph for this function:

◆ cold_tx_aux_import()

void tools::wallet2::cold_tx_aux_import	(	const std::vector< pending_tx > &	ptx,
		const std::vector< std::string > &	tx_device_aux
	)

Definition at line 10445 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(ptx.size() == tx_device_aux.size(), "TX aux has invalid size");
   for (size_t i = 0; i < ptx.size(); ++i){
     crypto::hash txid;
     txid = get_transaction_hash(ptx[i].tx);
     set_tx_device_aux(txid, tx_device_aux[i]);
   }
 }

Here is the call graph for this function:

◆ commit_tx() [1/2]

void tools::wallet2::commit_tx ( pending_tx & ptx_vector )

Definition at line 6686 of file wallet2.cpp.

 {
   using namespace cryptonote;
   
   if(m_light_wallet) 
   {
     cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::request oreq;
     cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::response ores;
     oreq.address = get_account().get_public_address_str(m_nettype);
     oreq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
     oreq.tx = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(ptx.tx));
     m_daemon_rpc_mutex.lock();
     bool r = invoke_http_json("/submit_raw_tx", oreq, ores, rpc_timeout, "POST");
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "submit_raw_tx");
     // MyMonero and OpenMonero use different status strings
     THROW_WALLET_EXCEPTION_IF(ores.status != "OK" && ores.status != "success" , error::tx_rejected, ptx.tx, get_rpc_status(ores.status), ores.error);
   }
   else
   {
     // Normal submit
     COMMAND_RPC_SEND_RAW_TX::request req;
     req.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(ptx.tx));
     req.do_not_relay = false;
     req.do_sanity_checks = true;
     COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp;
     m_daemon_rpc_mutex.lock();
     bool r = invoke_http_json("/sendrawtransaction", req, daemon_send_resp, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "sendrawtransaction");
     THROW_WALLET_EXCEPTION_IF(daemon_send_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "sendrawtransaction");
     THROW_WALLET_EXCEPTION_IF(daemon_send_resp.status != CORE_RPC_STATUS_OK, error::tx_rejected, ptx.tx, get_rpc_status(daemon_send_resp.status), get_text_reason(daemon_send_resp));
     // sanity checks
     for (size_t idx: ptx.selected_transfers)
     {
       THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error,
           "Bad output index in selected transfers: " + boost::lexical_cast<std::string>(idx));
     }
   }
   crypto::hash txid;
  
   txid = get_transaction_hash(ptx.tx);
   crypto::hash payment_id = crypto::null_hash;
   std::vector<cryptonote::tx_destination_entry> dests;
   uint64_t amount_in = 0;
   if (store_tx_info())
   {
     payment_id = get_payment_id(ptx);
     dests = ptx.dests;
     for(size_t idx: ptx.selected_transfers)
       amount_in += m_transfers[idx].amount();
   }
   add_unconfirmed_tx(ptx.tx, amount_in, dests, payment_id, ptx.change_dts.amount, ptx.construction_data.subaddr_account, ptx.construction_data.subaddr_indices);
   if (store_tx_info())
   {
     m_tx_keys.insert(std::make_pair(txid, ptx.tx_key));
     m_additional_tx_keys.insert(std::make_pair(txid, ptx.additional_tx_keys));
   }
  
   LOG_PRINT_L2("transaction " << txid << " generated ok and sent to daemon, key_images: [" << ptx.key_images << "]");
  
   for(size_t idx: ptx.selected_transfers)
   {
     set_spent(idx, 0);
   }
  
   // tx generated, get rid of used k values
   for (size_t idx: ptx.selected_transfers)
     m_transfers[idx].m_multisig_k.clear();
  
   //fee includes dust if dust policy specified it.
   LOG_PRINT_L1("Transaction successfully sent. <" << txid << ">" << ENDL
             << "Commission: " << print_etn(ptx.fee) << " (dust sent to dust addr: " << print_etn((ptx.dust_added_to_fee ? 0 : ptx.dust)) << ")" << ENDL
             << "Pre V10 Balance: " << print_etn(balance(ptx.construction_data.subaddr_account, false)) << ENDL
             << "Pre V10 Unlocked Balance: " << print_etn(unlocked_balance(ptx.construction_data.subaddr_account, false)) << ENDL
             << "Public Chain Balance: " << print_etn(balance(ptx.construction_data.subaddr_account, true)) << ENDL
             << "Public Chain Unlocked Balance: " << print_etn(unlocked_balance(ptx.construction_data.subaddr_account, true)) << ENDL
             << "Please, wait for confirmation for your balance to be unlocked.");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ commit_tx() [2/2]

void tools::wallet2::commit_tx ( std::vector< pending_tx > & ptx_vector )

Definition at line 6766 of file wallet2.cpp.

 {
   for (auto & ptx : ptx_vector)
   {
     commit_tx(ptx);
   }
 }

◆ confirm_backlog() [1/2]

bool tools::wallet2::confirm_backlog ( ) const

inline

Definition at line 1079 of file wallet2.h.

1079 { return m_confirm_backlog; }

◆ confirm_backlog() [2/2]

void tools::wallet2::confirm_backlog ( bool always )

inline

Definition at line 1080 of file wallet2.h.

1080 { m_confirm_backlog = always; }

◆ confirm_export_overwrite() [1/2]

bool tools::wallet2::confirm_export_overwrite ( ) const

inline

Definition at line 1083 of file wallet2.h.

1083 { return m_confirm_export_overwrite; }

◆ confirm_export_overwrite() [2/2]

void tools::wallet2::confirm_export_overwrite ( bool always )

inline

Definition at line 1084 of file wallet2.h.

1084 { m_confirm_export_overwrite = always; }

◆ confirm_missing_payment_id() [1/2]

bool tools::wallet2::confirm_missing_payment_id ( ) const

inline

Definition at line 1069 of file wallet2.h.

1069 { return m_confirm_missing_payment_id; }

◆ confirm_missing_payment_id() [2/2]

void tools::wallet2::confirm_missing_payment_id ( bool always )

inline

Definition at line 1070 of file wallet2.h.

1070 { m_confirm_missing_payment_id = always; }

◆ confirm_non_default_ring_size() [1/2]

bool tools::wallet2::confirm_non_default_ring_size ( ) const

inline

Definition at line 1095 of file wallet2.h.

1095 { return m_confirm_non_default_ring_size; }

◆ confirm_non_default_ring_size() [2/2]

void tools::wallet2::confirm_non_default_ring_size ( bool always )

inline

Definition at line 1096 of file wallet2.h.

1096 { m_confirm_non_default_ring_size = always; }

◆ create_transactions_2()

std::vector< wallet2::pending_tx > tools::wallet2::create_transactions_2	(	std::vector< cryptonote::tx_destination_entry >	dsts,
		const size_t	fake_outs_count,
		const uint64_t	unlock_time,
		uint32_t	priority,
		const std::vector< uint8_t > &	extra,
		uint32_t	subaddr_account,
		std::set< uint32_t >	subaddr_indices
	)

Definition at line 9515 of file wallet2.cpp.

 {
   //ensure device is let in NONE mode in any case
   hw::device &hwdev = m_account.get_device();
   boost::unique_lock<hw::device> hwdev_lock (hwdev);
   hw::reset_mode rst(hwdev);  
  
   //destinations in the full etn-address format
   auto original_dsts = dsts;
  
   if(m_light_wallet) {
     // Populate m_transfers
     light_wallet_get_unspent_outs();
   }
  
   uint8_t tx_version = this->public_transactions_required() ? 3 : 1;
   //vector of pairs of <subaddr minor index : vector<transfer indexes for that subaddr index inside m_transfers>>
   std::vector<std::pair<uint32_t, std::vector<size_t>>> unused_transfers_indices_per_subaddr;
   std::vector<std::pair<uint32_t, std::vector<size_t>>> unused_dust_indices_per_subaddr;
   uint64_t needed_etn;
   uint64_t accumulated_fee, accumulated_outputs, accumulated_change;
   struct TX {
     std::vector<size_t> selected_transfers;
     std::vector<cryptonote::tx_destination_entry> dsts;
     cryptonote::transaction tx;
     pending_tx ptx;
     size_t weight;
     uint64_t needed_fee;
     std::vector<std::vector<tools::wallet2::get_outs_entry>> outs;
  
     TX() : weight(0), needed_fee(0) {}
  
     void add(const cryptonote::tx_destination_entry &de, uint64_t amount, unsigned int original_output_index, bool merge_destinations) {
       if (merge_destinations)
       {
         std::vector<cryptonote::tx_destination_entry>::iterator i;
         i = std::find_if(dsts.begin(), dsts.end(), [&](const cryptonote::tx_destination_entry &d) { return !memcmp (&d.addr, &de.addr, sizeof(de.addr)); });
         if (i == dsts.end())
         {
           dsts.push_back(de);
           i = dsts.end() - 1;
           i->amount = 0;
         }
         i->amount += amount;
       }
       else
       {
         THROW_WALLET_EXCEPTION_IF(original_output_index > dsts.size(), error::wallet_internal_error,
             std::string("original_output_index too large: ") + std::to_string(original_output_index) + " > " + std::to_string(dsts.size()));
         if (original_output_index == dsts.size())
         {
           dsts.push_back(de);
           dsts.back().amount = 0;
         }
         THROW_WALLET_EXCEPTION_IF(memcmp(&dsts[original_output_index].addr, &de.addr, sizeof(de.addr)), error::wallet_internal_error, "Mismatched destination address");
         dsts[original_output_index].amount += amount;
       }
     }
   };
   std::vector<TX> txes;
   bool adding_fee; // true if new outputs go towards fee, rather than destinations
  
   uint64_t needed_fee, available_for_fee = 0;
   uint64_t upper_transaction_weight_limit;
   uint64_t extra_bytes = extra.size();
   switch(hwdev.get_type()){
  
       // Normal Software Limit
       case 0 : upper_transaction_weight_limit = get_upper_transaction_weight_limit(); break;
  
       // Ledger NanoS: ~3.3kB of RAM for app variables. Give a bit of buffer (300) for other variables on device
       // and subtract the size of the extra.
       // because in the Ledger app this still lives on the stack at the same time the entire prefix does.
       // This is a rough rule of thumb estimate... The logic can be updated at a later stage.
       // Right now we just need to make we don't fail to build any tx (and split the tx to avoid this happening)
       case 1 : upper_transaction_weight_limit = 3000 - extra_bytes; break;
  
       //Trezor limit set at the same as Ledger for the time being.
       case 2 : upper_transaction_weight_limit = 3000 - extra_bytes; break;
       //Future hw devices
   }
   const bool use_per_byte_fee = use_fork_rules(HF_VERSION_PER_BYTE_FEE, 0);
   const bool use_rct = use_fork_rules(HF_VERSION_ENABLE_RCT, 0);
   const bool bulletproof = use_fork_rules(get_bulletproof_fork(), 0);
   const rct::RCTConfig rct_config {
     bulletproof ? rct::RangeProofPaddedBulletproof : rct::RangeProofBorromean,
     bulletproof ? (use_fork_rules(HF_VERSION_SMALLER_BP, -10) ? 2 : 1) : 0
   };
  
   const uint64_t base_fee  = get_base_fee();
   const uint64_t fee_multiplier = get_fee_multiplier(priority, get_fee_algorithm());
   const uint64_t fee_quantization_mask = get_fee_quantization_mask();
  
   // throw if attempting a transaction with no destinations
   THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
  
   // calculate total amount being sent to all destinations
   // throw if total amount overflows uint64_t
   needed_etn = 0;
   for(auto& dt: dsts)
   {
     THROW_WALLET_EXCEPTION_IF(0 == dt.amount, error::zero_destination);
     needed_etn += dt.amount;
     LOG_PRINT_L2("transfer: adding " << print_etn(dt.amount) << ", for a total of " << print_etn (needed_etn));
     THROW_WALLET_EXCEPTION_IF(needed_etn < dt.amount, error::tx_sum_overflow, dsts, 0, m_nettype);
   }
  
   // throw if attempting a transaction with no etn
   THROW_WALLET_EXCEPTION_IF(needed_etn == 0, error::zero_destination);
  
   std::map<uint32_t, std::pair<uint64_t, uint64_t>> unlocked_balance_per_subaddr = unlocked_balance_per_subaddress(subaddr_account, tx_version >= 3);
   std::map<uint32_t, uint64_t> balance_per_subaddr = balance_per_subaddress(subaddr_account, tx_version >= 3);
  
   if (subaddr_indices.empty()) // "index=<N1>[,<N2>,...]" wasn't specified -> use all the indices with non-zero unlocked balance
   {
     for (const auto& i : balance_per_subaddr)
       subaddr_indices.insert(i.first);
   }
  
   // early out if we know we can't make it anyway
   // we could also check for being within FEE_PER_KB, but if the fee calculation
   // ever changes, this might be missed, so let this go through
   uint64_t min_fee = (fee_multiplier * base_fee * estimate_tx_size(use_rct, 1, fake_outs_count, 2, extra.size(), bulletproof));
   //Whilst we're still dealing with fee/kb:
   if (!use_per_byte_fee){
       min_fee /= 1000;
       if(min_fee == 0){min_fee += 10;}
   }
   uint64_t balance_subtotal = 0;
   uint64_t unlocked_balance_subtotal = 0;
   for (uint32_t index_minor : subaddr_indices)
   {
     balance_subtotal += balance_per_subaddr[index_minor];
     unlocked_balance_subtotal += unlocked_balance_per_subaddr[index_minor].first;
   }
   THROW_WALLET_EXCEPTION_IF(needed_etn + min_fee > balance_subtotal, error::not_enough_etn,
     balance_subtotal, needed_etn, 0);
   // first check overall balance is enough, then unlocked one, so we throw distinct exceptions
   THROW_WALLET_EXCEPTION_IF(needed_etn + min_fee > unlocked_balance_subtotal, error::not_enough_unlocked_etn,
       unlocked_balance_subtotal, needed_etn, 0);
  
   for (uint32_t i : subaddr_indices)
     LOG_PRINT_L2("Candidate subaddress index for spending: " << i);
  
   // determine threshold for fractional amount
   const size_t tx_weight_one_ring = estimate_tx_weight(use_rct, 1, fake_outs_count, 2, 0, bulletproof);
   const size_t tx_weight_two_rings = estimate_tx_weight(use_rct, 2, fake_outs_count, 2, 0, bulletproof);
   THROW_WALLET_EXCEPTION_IF(tx_weight_one_ring > tx_weight_two_rings, error::wallet_internal_error, "Estimated tx weight with 1 input is larger than with 2 inputs!");
   const size_t tx_weight_per_ring = tx_weight_two_rings - tx_weight_one_ring;
   const uint64_t fractional_threshold = (fee_multiplier * base_fee * tx_weight_per_ring) / (use_per_byte_fee ? 1 : 1024);
  
   // gather all dust and non-dust outputs belonging to specified subaddresses
   size_t num_nondust_outputs = 0;
   size_t num_dust_outputs = 0;
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     const transfer_details& td = m_transfers[i];
     if (m_ignore_fractional_outputs && td.amount() < fractional_threshold)
     {
       MDEBUG("Ignoring output " << i << " of amount " << print_etn(td.amount()) << " which is below threshold " << print_etn(fractional_threshold));
       continue;
     }
     if (!td.m_spent && !td.m_frozen && (!td.m_key_image_partial || td.m_tx.version > 1) && (use_rct ? true : !td.is_rct()) && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && subaddr_indices.count(td.m_subaddr_index.minor) == 1)
     {
       if((tx_version < 3 && td.m_tx.version > 1) || (tx_version >= 3 && td.m_tx.version == 1))
           continue;
  
       const uint32_t index_minor = td.m_subaddr_index.minor;
       auto find_predicate = [&index_minor](const std::pair<uint32_t, std::vector<size_t>>& x) { return x.first == index_minor; };
       if ((td.is_rct()) || is_valid_decomposed_amount(td.amount()))
       {
         auto found = std::find_if(unused_transfers_indices_per_subaddr.begin(), unused_transfers_indices_per_subaddr.end(), find_predicate);
         if (found == unused_transfers_indices_per_subaddr.end())
         {
           unused_transfers_indices_per_subaddr.push_back({index_minor, {i}});
         }
         else
         {
           found->second.push_back(i);
         }
         ++num_nondust_outputs;
       }
       else
       {
         auto found = std::find_if(unused_dust_indices_per_subaddr.begin(), unused_dust_indices_per_subaddr.end(), find_predicate);
         if (found == unused_dust_indices_per_subaddr.end())
         {
           unused_dust_indices_per_subaddr.push_back({index_minor, {i}});
         }
         else
         {
           found->second.push_back(i);
         }
         ++num_dust_outputs;
       }
     }
   }
  
   // sort output indices
   {
     auto sort_predicate = [&unlocked_balance_per_subaddr] (const std::pair<uint32_t, std::vector<size_t>>& x, const std::pair<uint32_t, std::vector<size_t>>& y)
     {
       return unlocked_balance_per_subaddr[x.first].first > unlocked_balance_per_subaddr[y.first].first;
     };
     std::sort(unused_transfers_indices_per_subaddr.begin(), unused_transfers_indices_per_subaddr.end(), sort_predicate);
     std::sort(unused_dust_indices_per_subaddr.begin(), unused_dust_indices_per_subaddr.end(), sort_predicate);
   }
  
   LOG_PRINT_L2("Starting with " << num_nondust_outputs << " non-dust outputs and " << num_dust_outputs << " dust outputs");
  
   if (unused_dust_indices_per_subaddr.empty() && unused_transfers_indices_per_subaddr.empty())
     return std::vector<wallet2::pending_tx>();
  
   // if empty, put dummy entry so that the front can be referenced later in the loop
   if (unused_dust_indices_per_subaddr.empty())
     unused_dust_indices_per_subaddr.push_back({});
   if (unused_transfers_indices_per_subaddr.empty())
     unused_transfers_indices_per_subaddr.push_back({});
  
   // start with an empty tx
   txes.push_back(TX());
   accumulated_fee = 0;
   accumulated_outputs = 0;
   accumulated_change = 0;
   adding_fee = false;
   needed_fee = 0;
   std::vector<std::vector<tools::wallet2::get_outs_entry>> outs;
  
   // for rct, since we don't see the amounts, we will try to make all transactions
   // look the same, with 1 or 2 inputs, and 2 outputs. One input is preferable, as
   // this prevents linking to another by provenance analysis, but two is ok if we
   // try to pick outputs not from the same block. We will get two outputs, one for
   // the destination, and one for change.
   LOG_PRINT_L2("checking preferred");
   std::vector<size_t> preferred_inputs;
   uint64_t rct_outs_needed = 2 * (fake_outs_count + 1);
   rct_outs_needed += 100; // some fudge factor since we don't know how many are locked
   if (use_rct)
   {
     // this is used to build a tx that's 1 or 2 inputs, and 2 outputs, which
     // will get us a known fee.
     uint64_t estimated_fee = estimate_fee(use_per_byte_fee, use_rct, 2, fake_outs_count, 2, extra.size(), bulletproof, base_fee, fee_multiplier, fee_quantization_mask);
     preferred_inputs = pick_preferred_rct_inputs(needed_etn + estimated_fee, subaddr_account, subaddr_indices);
     if (!preferred_inputs.empty())
     {
       string s;
       for (auto i: preferred_inputs) s += boost::lexical_cast<std::string>(i) + " (" + print_etn(m_transfers[i].amount()) + ") ";
       LOG_PRINT_L1("Found preferred rct inputs for rct tx: " << s);
  
       // bring the list of available outputs stored by the same subaddress index to the front of the list
       uint32_t index_minor = m_transfers[preferred_inputs[0]].m_subaddr_index.minor;
       for (size_t i = 1; i < unused_transfers_indices_per_subaddr.size(); ++i)
       {
         if (unused_transfers_indices_per_subaddr[i].first == index_minor)
         {
           std::swap(unused_transfers_indices_per_subaddr[0], unused_transfers_indices_per_subaddr[i]);
           break;
         }
       }
       for (size_t i = 1; i < unused_dust_indices_per_subaddr.size(); ++i)
       {
         if (unused_dust_indices_per_subaddr[i].first == index_minor)
         {
           std::swap(unused_dust_indices_per_subaddr[0], unused_dust_indices_per_subaddr[i]);
           break;
         }
       }
     }
   }
   LOG_PRINT_L2("done checking preferred");
  
   // while:
   // - we have something to send
   // - or we need to gather more fee
   // - or we have just one input in that tx, which is rct (to try and make all/most rct txes 2/2)
   unsigned int original_output_index = 0;
   std::vector<size_t>* unused_transfers_indices = &unused_transfers_indices_per_subaddr[0].second;
   std::vector<size_t>* unused_dust_indices      = &unused_dust_indices_per_subaddr[0].second;
   
   hwdev.set_mode(hw::device::TRANSACTION_CREATE_FAKE);
   while ((!dsts.empty() && dsts[0].amount > 0) || adding_fee || !preferred_inputs.empty() || should_pick_a_second_output(use_rct, txes.back().selected_transfers.size(), *unused_transfers_indices, *unused_dust_indices)) {
     TX &tx = txes.back();
  
     LOG_PRINT_L2("Start of loop with " << unused_transfers_indices->size() << " " << unused_dust_indices->size() << ", tx.dsts.size() " << tx.dsts.size());
     LOG_PRINT_L2("unused_transfers_indices: " << strjoin(*unused_transfers_indices, " "));
     LOG_PRINT_L2("unused_dust_indices: " << strjoin(*unused_dust_indices, " "));
     LOG_PRINT_L2("dsts size " << dsts.size() << ", first " << (dsts.empty() ? "-" : cryptonote::print_etn(dsts[0].amount)));
     LOG_PRINT_L2("adding_fee " << adding_fee << ", use_rct " << use_rct);
  
     // if we need to spend etn and don't have any left, we fail
     if (unused_dust_indices->empty() && unused_transfers_indices->empty()) {
       LOG_PRINT_L2("No more outputs to choose from");
       THROW_WALLET_EXCEPTION_IF(1, error::tx_not_possible, unlocked_balance(subaddr_account, tx_version >= 3), needed_etn, accumulated_fee + needed_fee);
     }
  
     // get a random unspent output and use it to pay part (or all) of the current destination (and maybe next one, etc)
     // This could be more clever, but maybe at the cost of making probabilistic inferences easier
     size_t idx;
     if (!preferred_inputs.empty()) {
       idx = pop_back(preferred_inputs);
       pop_if_present(*unused_transfers_indices, idx);
       pop_if_present(*unused_dust_indices, idx);
     } else if ((dsts.empty() || dsts[0].amount == 0) && !adding_fee) {
       // the "make rct txes 2/2" case - we pick a small value output to "clean up" the wallet too
       std::vector<size_t> indices = get_only_rct(*unused_dust_indices, *unused_transfers_indices);
       idx = pop_best_value(indices, tx.selected_transfers, true);
  
       // we might not want to add it if it's a large output and we don't have many left
       uint64_t min_output_value = m_min_output_value;
       uint32_t min_output_count = m_min_output_count;
       if (min_output_value == 0 && min_output_count == 0)
       {
         min_output_value = DEFAULT_MIN_OUTPUT_VALUE;
         min_output_count = DEFAULT_MIN_OUTPUT_COUNT;
       }
       if (m_transfers[idx].amount() >= min_output_value) {
         if (get_count_above(m_transfers, *unused_transfers_indices, min_output_value) < min_output_count) {
           LOG_PRINT_L2("Second output was not strictly needed, and we're running out of outputs above " << print_etn(min_output_value) << ", not adding");
           break;
         }
       }
  
       // since we're trying to add a second output which is not strictly needed,
       // we only add it if it's unrelated enough to the first one
       float relatedness = get_output_relatedness(m_transfers[idx], m_transfers[tx.selected_transfers.front()]);
       if (relatedness > SECOND_OUTPUT_RELATEDNESS_THRESHOLD)
       {
         LOG_PRINT_L2("Second output was not strictly needed, and relatedness " << relatedness << ", not adding");
         break;
       }
       pop_if_present(*unused_transfers_indices, idx);
       pop_if_present(*unused_dust_indices, idx);
     } else
       idx = pop_best_value(unused_transfers_indices->empty() ? *unused_dust_indices : *unused_transfers_indices, tx.selected_transfers);
  
     const transfer_details &td = m_transfers[idx];
     LOG_PRINT_L2("Picking output " << idx << ", amount " << print_etn(td.amount()) << ", ki " << td.m_key_image);
  
     // add this output to the list to spend
     tx.selected_transfers.push_back(idx);
     uint64_t available_amount = td.amount();
     accumulated_outputs += available_amount;
  
     // clear any fake outs we'd already gathered, since we'll need a new set
     outs.clear();
  
     if (adding_fee)
     {
       LOG_PRINT_L2("We need more fee, adding it to fee");
       available_for_fee += available_amount;
     }
     else
     {
       while (!dsts.empty() && dsts[0].amount <= available_amount && estimate_tx_weight(use_rct, tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), bulletproof) < TX_WEIGHT_TARGET(upper_transaction_weight_limit))
       {
         // we can fully pay that destination
         LOG_PRINT_L2("We can fully pay " << get_account_address_as_str(m_nettype, dsts[0].is_subaddress, dsts[0].addr) <<
           " for " << print_etn(dsts[0].amount));
         tx.add(dsts[0], dsts[0].amount, original_output_index, m_merge_destinations);
         available_amount -= dsts[0].amount;
         dsts[0].amount = 0;
         pop_index(dsts, 0);
         ++original_output_index;
       }
  
       if (available_amount > 0 && !dsts.empty() && estimate_tx_weight(use_rct, tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), bulletproof) < TX_WEIGHT_TARGET(upper_transaction_weight_limit)) {
         // we can partially fill that destination
         LOG_PRINT_L2("We can partially pay " << get_account_address_as_str(m_nettype, dsts[0].is_subaddress, dsts[0].addr) <<
           " for " << print_etn(available_amount) << "/" << print_etn(dsts[0].amount));
         tx.add(dsts[0], available_amount, original_output_index, m_merge_destinations);
         dsts[0].amount -= available_amount;
         available_amount = 0;
       }
     }
  
     // here, check if we need to sent tx and start a new one
     LOG_PRINT_L2("Considering whether to create a tx now, " << tx.selected_transfers.size() << " inputs, tx limit "
       << upper_transaction_weight_limit);
     bool try_tx = false;
     // if we have preferred picks, but haven't yet used all of them, continue
     if (preferred_inputs.empty())
     {
       if (adding_fee)
       {
         /* might not actually be enough if adding this output bumps size to next kB, but we need to try */
         try_tx = available_for_fee >= needed_fee;
       }
       else
       {
         const size_t estimated_rct_tx_weight = estimate_tx_weight(use_rct, tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), bulletproof);
         try_tx = dsts.empty() || (estimated_rct_tx_weight >= TX_WEIGHT_TARGET(upper_transaction_weight_limit));
         THROW_WALLET_EXCEPTION_IF(try_tx && tx.dsts.empty(), error::tx_too_big, estimated_rct_tx_weight, upper_transaction_weight_limit);
       }
     }
  
     if (try_tx) {
       cryptonote::transaction test_tx;
       test_tx.version = tx_version;
       pending_tx test_ptx;
  
       needed_fee = estimate_fee(use_per_byte_fee, use_rct ,tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), bulletproof, base_fee, fee_multiplier, fee_quantization_mask);
  
       uint64_t inputs = 0, outputs = needed_fee;
       for (size_t idx: tx.selected_transfers) inputs += m_transfers[idx].amount();
       for (const auto &o: tx.dsts) outputs += o.amount;
  
       if (inputs < outputs)
       {
         LOG_PRINT_L2("We don't have enough for the basic fee, switching to adding_fee");
         adding_fee = true;
         goto skip_tx;
       }
  
       LOG_PRINT_L2("Trying to create a tx now, with " << tx.dsts.size() << " outputs and " <<
         tx.selected_transfers.size() << " inputs");
  
       transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
       detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
       auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
       needed_fee = calculate_fee(use_per_byte_fee, test_ptx.tx, txBlob.size(), base_fee, fee_multiplier, fee_quantization_mask);
       available_for_fee = test_ptx.fee + test_ptx.change_dts.amount + (!test_ptx.dust_added_to_fee ? test_ptx.dust : 0);
       LOG_PRINT_L2("Made a " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_etn(available_for_fee) << " available for fee (" <<
         print_etn(needed_fee) << " needed)");
  
       if (needed_fee > available_for_fee && !dsts.empty() && dsts[0].amount > 0)
       {
         // we don't have enough for the fee, but we've only partially paid the current address,
         // so we can take the fee from the paid amount, since we'll have to make another tx anyway
         std::vector<cryptonote::tx_destination_entry>::iterator i;
         i = std::find_if(tx.dsts.begin(), tx.dsts.end(),
           [&](const cryptonote::tx_destination_entry &d) { return !memcmp (&d.addr, &dsts[0].addr, sizeof(dsts[0].addr)); });
         THROW_WALLET_EXCEPTION_IF(i == tx.dsts.end(), error::wallet_internal_error, "paid address not found in outputs");
         if (i->amount > needed_fee)
         {
           uint64_t new_paid_amount = i->amount /*+ test_ptx.fee*/ - needed_fee;
           LOG_PRINT_L2("Adjusting amount paid to " << get_account_address_as_str(m_nettype, i->is_subaddress, i->addr) << " from " <<
             print_etn(i->amount) << " to " << print_etn(new_paid_amount) << " to accommodate " <<
             print_etn(needed_fee) << " fee");
           dsts[0].amount += i->amount - new_paid_amount;
           i->amount = new_paid_amount;
           test_ptx.fee = needed_fee;
           available_for_fee = needed_fee;
         }
       }
  
       if (needed_fee > available_for_fee)
       {
         LOG_PRINT_L2("We could not make a tx, switching to fee accumulation");
  
         adding_fee = true;
       }
       else
       {
         LOG_PRINT_L2("We made a tx, adjusting fee and saving it, we need " << print_etn(needed_fee) << " and we have " << print_etn(test_ptx.fee));
         while (needed_fee > test_ptx.fee) {
           transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
           detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
           txBlob = t_serializable_object_to_blob(test_ptx.tx);
           needed_fee = calculate_fee(use_per_byte_fee, test_ptx.tx, txBlob.size(), base_fee, fee_multiplier, fee_quantization_mask);
           LOG_PRINT_L2("Made an attempt at a  final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_etn(test_ptx.fee) <<
             " fee  and " << print_etn(test_ptx.change_dts.amount) << " change");
         }
  
         LOG_PRINT_L2("Made a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_etn(test_ptx.fee) <<
           " fee  and " << print_etn(test_ptx.change_dts.amount) << " change");
  
         tx.tx = test_tx;
         tx.ptx = test_ptx;
         tx.weight = get_transaction_weight(test_tx, txBlob.size());
         tx.outs = outs;
         tx.needed_fee = test_ptx.fee;
         accumulated_fee += test_ptx.fee;
         accumulated_change += test_ptx.change_dts.amount;
         adding_fee = false;
         if (!dsts.empty())
         {
           LOG_PRINT_L2("We have more to pay, starting another tx");
           txes.push_back(TX());
           original_output_index = 0;
         }
       }
     }
  
 skip_tx:
     // if unused_*_indices is empty while unused_*_indices_per_subaddr has multiple elements, and if we still have something to pay, 
     // pop front of unused_*_indices_per_subaddr and have unused_*_indices point to the front of unused_*_indices_per_subaddr
     if ((!dsts.empty() && dsts[0].amount > 0) || adding_fee)
     {
       if (unused_transfers_indices->empty() && unused_transfers_indices_per_subaddr.size() > 1)
       {
         unused_transfers_indices_per_subaddr.erase(unused_transfers_indices_per_subaddr.begin());
         unused_transfers_indices = &unused_transfers_indices_per_subaddr[0].second;
       }
       if (unused_dust_indices->empty() && unused_dust_indices_per_subaddr.size() > 1)
       {
         unused_dust_indices_per_subaddr.erase(unused_dust_indices_per_subaddr.begin());
         unused_dust_indices = &unused_dust_indices_per_subaddr[0].second;
       }
     }
   }
  
   if (adding_fee)
   {
     LOG_PRINT_L1("We ran out of outputs while trying to gather final fee");
     THROW_WALLET_EXCEPTION_IF(1, error::tx_not_possible, unlocked_balance(subaddr_account, tx_version >= 3), needed_etn, accumulated_fee + needed_fee);
   }
  
   LOG_PRINT_L1("Done creating " << txes.size() << " transactions, " << print_etn(accumulated_fee) <<
     " total fee, " << print_etn(accumulated_change) << " total change");
  
   hwdev.set_mode(hw::device::TRANSACTION_CREATE_REAL);
   for (std::vector<TX>::iterator i = txes.begin(); i != txes.end(); ++i)
   {
     TX &tx = *i;
     cryptonote::transaction test_tx;
     test_tx.version = tx_version;
     pending_tx test_ptx;
     transfer_selected(tx.dsts,
                         tx.selected_transfers,
                         fake_outs_count,
                         tx.outs,
                         unlock_time,
                         tx.needed_fee,
                         extra,
                         detail::digit_split_strategy,
                         tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD),
                         test_tx,
                         test_ptx);
  
     auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
     tx.tx = test_tx;
     tx.ptx = test_ptx;
     tx.weight = get_transaction_weight(test_tx, txBlob.size());
   }
  
   std::vector<wallet2::pending_tx> ptx_vector;
   for (std::vector<TX>::iterator i = txes.begin(); i != txes.end(); ++i)
   {
     TX &tx = *i;
     uint64_t tx_etn = 0;
     for (size_t idx: tx.selected_transfers)
       tx_etn += m_transfers[idx].amount();
     LOG_PRINT_L1("  Transaction " << (1+std::distance(txes.begin(), i)) << "/" << txes.size() <<
       " " << get_transaction_hash(tx.ptx.tx) << ": " << get_weight_string(tx.weight) << ", sending " << print_etn(tx_etn) << " in " << tx.selected_transfers.size() <<
       " outputs to " << tx.dsts.size() << " destination(s), including " <<
       print_etn(tx.ptx.fee) << " fee, " << print_etn(tx.ptx.change_dts.amount) << " change");
     ptx_vector.push_back(tx.ptx);
   }
  
   THROW_WALLET_EXCEPTION_IF(!sanity_check(ptx_vector, original_dsts), error::wallet_internal_error, "Created transaction(s) failed sanity check");
  
   // if we made it this far, we're OK to actually send the transactions
   return ptx_vector;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_transactions_all()

std::vector< wallet2::pending_tx > tools::wallet2::create_transactions_all	(	uint64_t	below,
		const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const size_t	outputs,
		const size_t	fake_outs_count,
		const uint64_t	unlock_time,
		uint32_t	priority,
		const std::vector< uint8_t > &	extra,
		uint32_t	subaddr_account,
		std::set< uint32_t >	subaddr_indices,
		const bool	migrate = `false`
	)

Definition at line 10149 of file wallet2.cpp.

 {
   std::vector<size_t> unused_transfers_indices;
   std::vector<size_t> unused_dust_indices;
   const bool use_rct = use_fork_rules(4, 0);
   uint8_t tx_version = public_transactions_required() ? (migrate ? 2 : 3) : 1;
   THROW_WALLET_EXCEPTION_IF(unlocked_balance(subaddr_account, tx_version >=3) == 0, error::wallet_internal_error, "No unlocked balance in the entire wallet");
   std::map<uint32_t, std::pair<std::vector<size_t>, std::vector<size_t>>> unused_transfer_dust_indices_per_subaddr;
  
   // gather all dust ***and*** non-dust outputs of specified subaddress (if any) and below specified threshold (if any)
   bool fund_found = false;
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     const transfer_details& td = m_transfers[i];
  
     if((tx_version < 3 && td.m_tx.version > 1) || (tx_version >= 3 && td.m_tx.version == 1))
         continue;
  
     if (!td.m_spent && !td.m_frozen && (!td.m_key_image_partial || tx_version >= 3) && (use_rct ? true : !td.is_rct()) && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && (subaddr_indices.empty() || subaddr_indices.count(td.m_subaddr_index.minor) == 1))
     {
       fund_found = true;
       if (below == 0 || td.amount() < below)
       {
         if ((td.is_rct()) || is_valid_decomposed_amount(td.amount()))
           unused_transfer_dust_indices_per_subaddr[td.m_subaddr_index.minor].first.push_back(i);
         else
           unused_transfer_dust_indices_per_subaddr[td.m_subaddr_index.minor].second.push_back(i);
       }
     }
   }
   THROW_WALLET_EXCEPTION_IF(!fund_found, error::wallet_internal_error, "No unlocked balance in the specified subaddress(es)");
   THROW_WALLET_EXCEPTION_IF(unused_transfer_dust_indices_per_subaddr.empty(), error::wallet_internal_error, "The smallest amount found is not below the specified threshold");
  
   if (subaddr_indices.empty())
   {
     // in case subaddress index wasn't specified, choose non-empty subaddress randomly (with index=0 being chosen last)
     if (unused_transfer_dust_indices_per_subaddr.count(0) == 1 && unused_transfer_dust_indices_per_subaddr.size() > 1)
       unused_transfer_dust_indices_per_subaddr.erase(0);
     auto i = unused_transfer_dust_indices_per_subaddr.begin();
     std::advance(i, crypto::rand_idx(unused_transfer_dust_indices_per_subaddr.size()));
     unused_transfers_indices = i->second.first;
     unused_dust_indices = i->second.second;
     LOG_PRINT_L2("Spending from subaddress index " << i->first);
   }
   else
   {
     for (const auto& p : unused_transfer_dust_indices_per_subaddr)
     {
       unused_transfers_indices.insert(unused_transfers_indices.end(), p.second.first.begin(), p.second.first.end());
       unused_dust_indices.insert(unused_dust_indices.end(), p.second.second.begin(), p.second.second.end());
       LOG_PRINT_L2("Spending from subaddress index " << p.first);
     }
   }
  
   return create_transactions_from(address, is_subaddress, outputs, unused_transfers_indices, unused_dust_indices, fake_outs_count, unlock_time, priority, extra, tx_version);
 }

Here is the call graph for this function:

◆ create_transactions_from()

std::vector< wallet2::pending_tx > tools::wallet2::create_transactions_from	(	const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const size_t	outputs,
		std::vector< size_t >	unused_transfers_indices,
		std::vector< size_t >	unused_dust_indices,
		const size_t	fake_outs_count,
		const uint64_t	unlock_time,
		uint32_t	priority,
		const std::vector< uint8_t > &	extra,
		const uint8_t	tx_version
	)

Definition at line 10229 of file wallet2.cpp.

 {
   //ensure device is let in NONE mode in any case
   hw::device &hwdev = m_account.get_device();
   boost::unique_lock<hw::device> hwdev_lock (hwdev);
   hw::reset_mode rst(hwdev);  
  
   uint64_t accumulated_fee, accumulated_outputs, accumulated_change;
   struct TX {
     std::vector<size_t> selected_transfers;
     std::vector<cryptonote::tx_destination_entry> dsts;
     cryptonote::transaction tx;
     pending_tx ptx;
     size_t weight;
     uint64_t needed_fee;
     std::vector<std::vector<get_outs_entry>> outs;
  
     TX() : weight(0), needed_fee(0) {}
   };
   std::vector<TX> txes;
   uint64_t needed_fee, available_for_fee = 0;
   uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit(); //max size of a tx - usually ~ half the block size
   std::vector<std::vector<get_outs_entry>> outs;
  
   const bool use_per_byte_fee = use_fork_rules(HF_VERSION_PER_BYTE_FEE);
   const bool use_rct = fake_outs_count > 0 && use_fork_rules(4, 0);
   const bool bulletproof = use_fork_rules(get_bulletproof_fork(), 0);
   const rct::RCTConfig rct_config {
     bulletproof ? rct::RangeProofPaddedBulletproof : rct::RangeProofBorromean,
     bulletproof ? (use_fork_rules(HF_VERSION_SMALLER_BP, -10) ? 2 : 1) : 0,
   };
   const uint64_t base_fee  = get_base_fee();
   const uint64_t fee_multiplier = get_fee_multiplier(priority, get_fee_algorithm());
   const uint64_t fee_quantization_mask = get_fee_quantization_mask();
  
   LOG_PRINT_L2("Starting with " << unused_transfers_indices.size() << " non-dust outputs and " << unused_dust_indices.size() << " dust outputs");
  
   if (unused_dust_indices.empty() && unused_transfers_indices.empty())
     return std::vector<wallet2::pending_tx>();
  
   // start with an empty tx
   txes.push_back(TX());
   accumulated_fee = 0;
   accumulated_outputs = 0;
   accumulated_change = 0;
   needed_fee = 0;
  
   // while we have something to send
   hwdev.set_mode(hw::device::TRANSACTION_CREATE_FAKE);
   while (!unused_dust_indices.empty() || !unused_transfers_indices.empty()) {
     TX &tx = txes.back();
  
     // get a random unspent output and use it to pay next chunk. We try to alternate
     // dust and non dust to ensure we never get with only dust, from which we might
     // get a tx that can't pay for itself
     uint64_t fee_dust_threshold;
     if (use_fork_rules(HF_VERSION_PER_BYTE_FEE))
     {
       const uint64_t estimated_tx_weight_with_one_extra_output = estimate_tx_weight(use_rct, tx.selected_transfers.size() + 1, fake_outs_count, tx.dsts.size()+1, extra.size(), bulletproof);
       fee_dust_threshold = calculate_fee_from_weight(base_fee, estimated_tx_weight_with_one_extra_output, fee_multiplier, fee_quantization_mask);
     }
     else
     {
       fee_dust_threshold = base_fee * fee_multiplier * (upper_transaction_weight_limit + 1023) / 1024;
     }
  
     size_t idx =
       unused_transfers_indices.empty()
         ? pop_best_value(unused_dust_indices, tx.selected_transfers)
       : unused_dust_indices.empty()
         ? pop_best_value(unused_transfers_indices, tx.selected_transfers)
       : ((tx.selected_transfers.size() & 1) || accumulated_outputs > fee_dust_threshold)
         ? pop_best_value(unused_dust_indices, tx.selected_transfers)
       : pop_best_value(unused_transfers_indices, tx.selected_transfers);
  
     const transfer_details &td = m_transfers[idx];
     LOG_PRINT_L2("Picking output " << idx << ", amount " << print_etn(td.amount()));
  
     // add this output to the list to spend
     tx.selected_transfers.push_back(idx);
     uint64_t available_amount = td.amount();
     accumulated_outputs += available_amount;
  
     // clear any fake outs we'd already gathered, since we'll need a new set
     outs.clear();
  
     // here, check if we need to sent tx and start a new one
     LOG_PRINT_L2("Considering whether to create a tx now, " << tx.selected_transfers.size() << " inputs, tx limit "
       << upper_transaction_weight_limit);
     const size_t estimated_rct_tx_weight = estimate_tx_weight(use_rct, tx.selected_transfers.size(), fake_outs_count, tx.dsts.size() + 2, extra.size(), bulletproof);
     bool try_tx = (unused_dust_indices.empty() && unused_transfers_indices.empty()) || ( estimated_rct_tx_weight >= TX_WEIGHT_TARGET(upper_transaction_weight_limit));
  
     if (try_tx) {
       cryptonote::transaction test_tx;
       test_tx.version = tx_version;
       pending_tx test_ptx;
  
       needed_fee = tx_version == 2 ? 0 : estimate_fee(use_per_byte_fee, use_rct, tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), bulletproof, base_fee, fee_multiplier, fee_quantization_mask);
  
       // add N - 1 outputs for correct initial fee estimation
       for (size_t i = 0; i < ((outputs > 1) ? outputs - 1 : outputs); ++i)
         tx.dsts.push_back(tx_destination_entry(1, address, is_subaddress));
  
       LOG_PRINT_L2("Trying to create a tx now, with " << tx.dsts.size() << " destinations and " <<
       tx.selected_transfers.size() << " outputs");
  
       transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
         detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
  
       auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
       needed_fee = tx_version == 2 ? 0 : calculate_fee(use_per_byte_fee, test_ptx.tx, txBlob.size(), base_fee, fee_multiplier, fee_quantization_mask);
       available_for_fee = test_ptx.fee + test_ptx.change_dts.amount;
       for (auto &dt: test_ptx.dests)
         available_for_fee += dt.amount;
       LOG_PRINT_L2("Made a " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_etn(available_for_fee) << " available for fee (" <<
         print_etn(needed_fee) << " needed)");
  
       // add last output, missed for fee estimation
       if (outputs > 1)
         tx.dsts.push_back(tx_destination_entry(1, address, is_subaddress));
  
       THROW_WALLET_EXCEPTION_IF(needed_fee > available_for_fee, error::wallet_internal_error, "Transaction cannot pay for itself");
  
       do {
         LOG_PRINT_L2("We made a tx, adjusting fee and saving it");
         // distribute total transferred amount between outputs
         uint64_t amount_transferred = available_for_fee - needed_fee; //shouuld be zero for migration transactions
         uint64_t dt_amount = amount_transferred / outputs;
         // residue is distributed as one atomic unit per output until it reaches zero
         uint64_t residue = amount_transferred % outputs;
         for (auto &dt: tx.dsts)
         {
           uint64_t dt_residue = 0;
           if (residue > 0)
           {
             dt_residue = 1;
             residue -= 1;
           }
           dt.amount = dt_amount + dt_residue;
         }
         transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
         detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
         txBlob = t_serializable_object_to_blob(test_ptx.tx);
         needed_fee = tx_version == 2 ? 0 : calculate_fee(use_per_byte_fee, test_ptx.tx, txBlob.size(), base_fee, fee_multiplier, fee_quantization_mask);
         LOG_PRINT_L2("Made an attempt at a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_etn(test_ptx.fee) <<
           " fee  and " << print_etn(test_ptx.change_dts.amount) << " change");
       } while (needed_fee > test_ptx.fee);
  
       LOG_PRINT_L2("Made a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_etn(test_ptx.fee) <<
         " fee  and " << print_etn(test_ptx.change_dts.amount) << " change");
  
       tx.tx = test_tx;
       tx.ptx = test_ptx;
       tx.weight = get_transaction_weight(test_tx, txBlob.size());
       tx.outs = outs;
       tx.needed_fee = test_ptx.fee;
       accumulated_fee += test_ptx.fee;
       accumulated_change += test_ptx.change_dts.amount;
       if (!unused_transfers_indices.empty() || !unused_dust_indices.empty())
       {
         LOG_PRINT_L2("We have more to pay, starting another tx");
         txes.push_back(TX());
       }
     }
   }
  
   LOG_PRINT_L1("Done creating " << txes.size() << " transactions, " << print_etn(accumulated_fee) <<
     " total fee, " << print_etn(accumulated_change) << " total change");
  
   hwdev.set_mode(hw::device::TRANSACTION_CREATE_REAL);
   for (std::vector<TX>::iterator i = txes.begin(); i != txes.end(); ++i)
   {
     TX &tx = *i;
     cryptonote::transaction test_tx;
     test_tx.version = tx_version;
     pending_tx test_ptx;
     transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, tx.outs, unlock_time, tx.needed_fee, extra,
     detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
  
     auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
     tx.tx = test_tx;
     tx.ptx = test_ptx;
     tx.weight = get_transaction_weight(test_tx, txBlob.size());
   }
  
   std::vector<wallet2::pending_tx> ptx_vector;
   for (std::vector<TX>::iterator i = txes.begin(); i != txes.end(); ++i)
   {
     TX &tx = *i;
     uint64_t tx_etn = 0;
     for (size_t idx: tx.selected_transfers)
       tx_etn += m_transfers[idx].amount();
     LOG_PRINT_L1("  Transaction " << (1+std::distance(txes.begin(), i)) << "/" << txes.size() <<
       " " << get_transaction_hash(tx.ptx.tx) << ": " << get_weight_string(tx.weight) << ", sending " << print_etn(tx_etn) << " in " << tx.selected_transfers.size() <<
       " outputs to " << tx.dsts.size() << " destination(s), including " <<
       print_etn(tx.ptx.fee) << " fee, " << print_etn(tx.ptx.change_dts.amount) << " change");
     ptx_vector.push_back(tx.ptx);
   }
  
   uint64_t a = 0;
   for (const TX &tx: txes)
   {
     for (size_t idx: tx.selected_transfers)
     {
       a += m_transfers[idx].amount();
     }
     a -= tx.ptx.fee;
   }
   std::vector<cryptonote::tx_destination_entry> synthetic_dsts(1, cryptonote::tx_destination_entry("", a, address, is_subaddress));
   THROW_WALLET_EXCEPTION_IF(!sanity_check(ptx_vector, synthetic_dsts), error::wallet_internal_error, "Created transaction(s) failed sanity check");
  
   // if we made it this far, we're OK to actually send the transactions
   return ptx_vector;
 }

Here is the call graph for this function:

◆ create_transactions_single()

std::vector< wallet2::pending_tx > tools::wallet2::create_transactions_single	(	const crypto::key_image &	ki,
		const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const size_t	outputs,
		const size_t	fake_outs_count,
		const uint64_t	unlock_time,
		uint32_t	priority,
		const std::vector< uint8_t > &	extra
	)

Definition at line 10206 of file wallet2.cpp.

 {
   std::vector<size_t> unused_transfers_indices;
   std::vector<size_t> unused_dust_indices;
   uint8_t tx_version = 1; //todo: 4.0.0.0 leave it as this for now until we update it for sending by chainstate index
   const bool use_rct = use_fork_rules(4, 0);
   // find output with the given key image (
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     const transfer_details& td = m_transfers[i];
  
     if (td.m_key_image_known && td.m_tx.version == 1 && td.m_key_image == ki && !td.m_spent && !td.m_frozen && (use_rct ? true : !td.is_rct()) && is_transfer_unlocked(td))
     {
       if (td.is_rct() || is_valid_decomposed_amount(td.amount()))
         unused_transfers_indices.push_back(i);
       else
         unused_dust_indices.push_back(i);
       break;
     }
   }
   return create_transactions_from(address, is_subaddress, outputs, unused_transfers_indices, unused_dust_indices, fake_outs_count, unlock_time, priority, extra, tx_version);
 }

Here is the call graph for this function:

◆ create_unmixable_sweep_transactions()

std::vector< wallet2::pending_tx > tools::wallet2::create_unmixable_sweep_transactions ( )

Definition at line 10660 of file wallet2.cpp.

 {
   // From hard fork 1, we don't consider small amounts to be dust anymore
   const bool hf1_rules = use_fork_rules(2, 10); // first hard fork has version 2
   tx_dust_policy dust_policy(hf1_rules ? 0 : ::config::DEFAULT_DUST_THRESHOLD);
  
   uint8_t tx_version = this->public_transactions_required() ? 3 : 1;
   const uint64_t base_fee  = get_base_fee();
  
   // may throw
   std::vector<size_t> unmixable_outputs = select_available_unmixable_outputs();
   size_t num_dust_outputs = unmixable_outputs.size();
  
   if (num_dust_outputs == 0)
   {
     return std::vector<wallet2::pending_tx>();
   }
  
   // split in "dust" and "non dust" to make it easier to select outputs
   std::vector<size_t> unmixable_transfer_outputs, unmixable_dust_outputs;
   for (auto n: unmixable_outputs)
   {
     if (m_transfers[n].amount() < base_fee)
       unmixable_dust_outputs.push_back(n);
     else
       unmixable_transfer_outputs.push_back(n);
   }
  
   return create_transactions_from(m_account_public_address, false, 1, unmixable_transfer_outputs, unmixable_dust_outputs, 0 /*fake_outs_count */, 0 /* unlock_time */, 1 /*priority */, std::vector<uint8_t>(), tx_version);
 }

◆ decrypt()

template<typename T >

template epee::wipeable_string tools::wallet2::decrypt	(	const std::string &	ciphertext,
		const crypto::secret_key &	skey,
		bool	authenticated = `true`
	)		const

Definition at line 13003 of file wallet2.cpp.

 {
   const size_t prefix_size = sizeof(chacha_iv) + (authenticated ? sizeof(crypto::signature) : 0);
   THROW_WALLET_EXCEPTION_IF(ciphertext.size() < prefix_size,
     error::wallet_internal_error, "Unexpected ciphertext size");
  
   crypto::chacha_key key;
   crypto::generate_chacha_key(&skey, sizeof(skey), key, m_kdf_rounds);
   const crypto::chacha_iv &iv = *(const crypto::chacha_iv*)&ciphertext[0];
   if (authenticated)
   {
     crypto::hash hash;
     crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
     crypto::public_key pkey;
     crypto::secret_key_to_public_key(skey, pkey);
     const crypto::signature &signature = *(const crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
     THROW_WALLET_EXCEPTION_IF(!crypto::check_signature(hash, pkey, signature),
       error::wallet_internal_error, "Failed to authenticate ciphertext");
   }
   std::unique_ptr<char[]> buffer{new char[ciphertext.size() - prefix_size]};
   auto wiper = epee::misc_utils::create_scope_leave_handler([&]() { memwipe(buffer.get(), ciphertext.size() - prefix_size); });
   crypto::chacha20(ciphertext.data() + sizeof(iv), ciphertext.size() - prefix_size, key, iv, buffer.get());
   return T(buffer.get(), ciphertext.size() - prefix_size);
 }

◆ decrypt_keys() [1/2]

void tools::wallet2::decrypt_keys ( const crypto::chacha_key & key )

Definition at line 4642 of file wallet2.cpp.

 {
   m_account.encrypt_viewkey(key);
   m_account.decrypt_keys(key);
 }

Here is the caller graph for this function:

◆ decrypt_keys() [2/2]

void tools::wallet2::decrypt_keys ( const epee::wipeable_string & password )

Definition at line 4655 of file wallet2.cpp.

 {
   crypto::chacha_key key;
   crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
   decrypt_keys(key);
 }

◆ decrypt_with_view_secret_key()

std::string tools::wallet2::decrypt_with_view_secret_key	(	const std::string &	ciphertext,
		bool	authenticated = `true`
	)		const

Definition at line 13030 of file wallet2.cpp.

 {
   return decrypt(ciphertext, get_account().get_keys().m_view_secret_key, authenticated);
 }

Here is the call graph for this function:

◆ default_mixin() [1/2]

uint32_t tools::wallet2::default_mixin ( ) const

inline

Definition at line 1063 of file wallet2.h.

1063 { return m_default_mixin; }

◆ default_mixin() [2/2]

void tools::wallet2::default_mixin ( uint32_t m )

inline

Definition at line 1064 of file wallet2.h.

1064 { m_default_mixin = m; }

◆ deinit()

bool tools::wallet2::deinit ( )

Definition at line 3921 of file wallet2.cpp.

 {
   m_is_initialized=false;
   unlock_keys_file();
   m_account.deinit();
   return true;
 }

◆ delete_address_book_row()

bool tools::wallet2::delete_address_book_row ( std::size_t row_id )

Definition at line 3449 of file wallet2.cpp.

                                                       {
   if(m_address_book.size() <= row_id)
     return false;
  
   m_address_book.erase(m_address_book.begin()+row_id);
  
   return true;
 }

◆ device_derivation_path() [1/2]

const std::string& tools::wallet2::device_derivation_path ( ) const

inline

Definition at line 1103 of file wallet2.h.

1103 { return m_device_derivation_path; }

◆ device_derivation_path() [2/2]

void tools::wallet2::device_derivation_path ( const std::string & device_derivation_path )

inline

Definition at line 1104 of file wallet2.h.

1104 { m_device_derivation_path = device_derivation_path; }

tools::wallet2::device_derivation_path

const std::string & device_derivation_path() const

Definition: wallet2.h:1103

Here is the call graph for this function:

Here is the caller graph for this function:

◆ device_derivation_path_option()

std::string tools::wallet2::device_derivation_path_option ( const boost::program_options::variables_map & vm )

static

Definition at line 1187 of file wallet2.cpp.

 {
   return command_line::get_arg(vm, options().hw_device_derivation_path);
 }

Here is the call graph for this function:

◆ device_name() [1/2]

const std::string& tools::wallet2::device_name ( ) const

inline

Definition at line 1101 of file wallet2.h.

1101 { return m_device_name; }

◆ device_name() [2/2]

void tools::wallet2::device_name ( const std::string & device_name )

inline

Definition at line 1102 of file wallet2.h.

1102 { m_device_name = device_name; }

tools::wallet2::device_name

const std::string & device_name() const

Definition: wallet2.h:1101

Here is the call graph for this function:

Here is the caller graph for this function:

◆ device_name_option()

std::string tools::wallet2::device_name_option ( const boost::program_options::variables_map & vm )

static

Definition at line 1182 of file wallet2.cpp.

 {
   return command_line::get_arg(vm, options().hw_device);
 }

Here is the call graph for this function:

◆ discard_unmixable_outputs()

void tools::wallet2::discard_unmixable_outputs ( )

Definition at line 10691 of file wallet2.cpp.

 {
   // may throw
   std::vector<size_t> unmixable_outputs = select_available_unmixable_outputs();
   for (size_t idx : unmixable_outputs)
   {
     freeze(idx);
   }
 }

◆ dump_tx_to_str()

std::string tools::wallet2::dump_tx_to_str ( const std::vector< pending_tx > & ptx_vector ) const

Definition at line 6783 of file wallet2.cpp.

 {
   LOG_PRINT_L0("saving " << ptx_vector.size() << " transactions");
   unsigned_tx_set txs;
   for (auto &tx: ptx_vector)
   {
     // Short payment id is encrypted with tx_key. 
     // Since sign_tx() generates new tx_keys and encrypts the payment id, we need to save the decrypted payment ID
     // Save tx construction_data to unsigned_tx_set
     txs.txes.push_back(get_construction_data_with_decrypted_short_payment_id(tx, m_account.get_device()));
   }
   
   txs.transfers = export_outputs();
   // save as binary
   std::ostringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   try
   {
     ar << txs;
   }
   catch (...)
   {
     return std::string();
   }
   LOG_PRINT_L2("Saving unsigned tx data: " << oss.str());
   std::string ciphertext = encrypt_with_view_secret_key(oss.str());
  
   return std::string(UNSIGNED_TX_PREFIX) + ciphertext;
 }

◆ enable_dns()

void tools::wallet2::enable_dns ( bool enable )

inline

Definition at line 1375 of file wallet2.h.

1375 { m_use_dns = enable; }

◆ encrypt() [1/4]

std::string tools::wallet2::encrypt	(	const char *	plaintext,
		size_t	len,
		const crypto::secret_key &	skey,
		bool	authenticated = `true`
	)		const

Definition at line 12961 of file wallet2.cpp.

 {
   crypto::chacha_key key;
   crypto::generate_chacha_key(&skey, sizeof(skey), key, m_kdf_rounds);
   std::string ciphertext;
   crypto::chacha_iv iv = crypto::rand<crypto::chacha_iv>();
   ciphertext.resize(len + sizeof(iv) + (authenticated ? sizeof(crypto::signature) : 0));
   crypto::chacha20(plaintext, len, key, iv, &ciphertext[sizeof(iv)]);
   memcpy(&ciphertext[0], &iv, sizeof(iv));
   if (authenticated)
   {
     crypto::hash hash;
     crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
     crypto::public_key pkey;
     crypto::secret_key_to_public_key(skey, pkey);
     crypto::signature &signature = *(crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
     crypto::generate_signature(hash, pkey, skey, signature);
   }
   return ciphertext;
 }

Here is the caller graph for this function:

◆ encrypt() [2/4]

std::string tools::wallet2::encrypt	(	const epee::span< char > &	span,
		const crypto::secret_key &	skey,
		bool	authenticated = `true`
	)		const

Definition at line 12982 of file wallet2.cpp.

 {
   return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
 }

◆ encrypt() [3/4]

std::string tools::wallet2::encrypt	(	const epee::wipeable_string &	plaintext,
		const crypto::secret_key &	skey,
		bool	authenticated = `true`
	)		const

Definition at line 12992 of file wallet2.cpp.

 {
   return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
 }

◆ encrypt() [4/4]

std::string tools::wallet2::encrypt	(	const std::string &	plaintext,
		const crypto::secret_key &	skey,
		bool	authenticated = `true`
	)		const

Definition at line 12987 of file wallet2.cpp.

 {
   return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
 }

◆ encrypt_keys() [1/2]

void tools::wallet2::encrypt_keys ( const crypto::chacha_key & key )

Definition at line 4636 of file wallet2.cpp.

 {
   m_account.encrypt_keys(key);
   m_account.decrypt_viewkey(key);
 }

Here is the caller graph for this function:

◆ encrypt_keys() [2/2]

void tools::wallet2::encrypt_keys ( const epee::wipeable_string & password )

Definition at line 4648 of file wallet2.cpp.

 {
   crypto::chacha_key key;
   crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
   encrypt_keys(key);
 }

◆ encrypt_with_view_secret_key()

std::string tools::wallet2::encrypt_with_view_secret_key	(	const std::string &	plaintext,
		bool	authenticated = `true`
	)		const

Definition at line 12997 of file wallet2.cpp.

 {
   return encrypt(plaintext, get_account().get_keys().m_view_secret_key, authenticated);
 }

◆ estimate_backlog() [1/2]

std::vector< std::pair< uint64_t, uint64_t > > tools::wallet2::estimate_backlog ( const std::vector< std::pair< double, double >> & fee_levels )

Definition at line 13269 of file wallet2.cpp.

 {
   for (const auto &fee_level: fee_levels)
   {
     THROW_WALLET_EXCEPTION_IF(fee_level.first == 0.0, error::wallet_internal_error, "Invalid 0 fee");
     THROW_WALLET_EXCEPTION_IF(fee_level.second == 0.0, error::wallet_internal_error, "Invalid 0 fee");
   }
  
   // get txpool backlog
   cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::request req = AUTO_VAL_INIT(req);
   cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::response res = AUTO_VAL_INIT(res);
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json_rpc("/json_rpc", "get_txpool_backlog", req, res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "Failed to connect to daemon");
   THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_txpool_backlog");
   THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::get_tx_pool_error);
  
   uint64_t block_weight_limit = 0;
   const auto result = m_node_rpc_proxy.get_block_weight_limit(block_weight_limit);
   throw_on_rpc_response_error(result, "get_info");
   uint64_t full_reward_zone = block_weight_limit / 2;
   THROW_WALLET_EXCEPTION_IF(full_reward_zone == 0, error::wallet_internal_error, "Invalid block weight limit from daemon");
  
   std::vector<std::pair<uint64_t, uint64_t>> blocks;
   for (const auto &fee_level: fee_levels)
   {
     const double our_fee_byte_min = fee_level.first;
     const double our_fee_byte_max = fee_level.second;
     uint64_t priority_weight_min = 0, priority_weight_max = 0;
     for (const auto &i: res.backlog)
     {
       if (i.weight == 0)
       {
         MWARNING("Got 0 weight tx from txpool, ignored");
         continue;
       }
       double this_fee_byte = i.fee / (double)i.weight;
       if (this_fee_byte >= our_fee_byte_min)
         priority_weight_min += i.weight;
       if (this_fee_byte >= our_fee_byte_max)
         priority_weight_max += i.weight;
     }
  
     uint64_t nblocks_min = priority_weight_min / full_reward_zone;
     uint64_t nblocks_max = priority_weight_max / full_reward_zone;
     MDEBUG("estimate_backlog: priority_weight " << priority_weight_min << " - " << priority_weight_max << " for "
         << our_fee_byte_min << " - " << our_fee_byte_max << " piconero byte fee, "
         << nblocks_min << " - " << nblocks_max << " blocks at block weight " << full_reward_zone);
     blocks.push_back(std::make_pair(nblocks_min, nblocks_max));
   }
   return blocks;
 }

Here is the call graph for this function:

◆ estimate_backlog() [2/2]

std::vector< std::pair< uint64_t, uint64_t > > tools::wallet2::estimate_backlog	(	uint64_t	min_tx_weight,
		uint64_t	max_tx_weight,
		const std::vector< uint64_t > &	fees
	)

Definition at line 13323 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(min_tx_weight == 0, error::wallet_internal_error, "Invalid 0 fee");
   THROW_WALLET_EXCEPTION_IF(max_tx_weight == 0, error::wallet_internal_error, "Invalid 0 fee");
   for (uint64_t fee: fees)
   {
     THROW_WALLET_EXCEPTION_IF(fee == 0, error::wallet_internal_error, "Invalid 0 fee");
   }
   std::vector<std::pair<double, double>> fee_levels;
   for (uint64_t fee: fees)
   {
     double our_fee_byte_min = fee / (double)min_tx_weight, our_fee_byte_max = fee / (double)max_tx_weight;
     fee_levels.emplace_back(our_fee_byte_min, our_fee_byte_max);
   }
   return estimate_backlog(fee_levels);
 }

◆ estimate_blockchain_height()

uint64_t tools::wallet2::estimate_blockchain_height ( )

Definition at line 4880 of file wallet2.cpp.

  {
    // -1 month for fluctuations in block time and machine date/time setup.
    // avg seconds per block
    const int seconds_per_block = DIFFICULTY_TARGET_V6;
    // ~num blocks per month
    const uint64_t blocks_per_month = 60*60*24*30/seconds_per_block;
  
    // try asking the daemon first
    std::string err;
    uint64_t height = 0;
  
    // we get the max of approximated height and local height.
    // approximated height is the least of daemon target height
    // (the max of what the other daemons are claiming is their
    // height) and the theoretical height based on the local
    // clock. This will be wrong only if both the local clock
    // is bad *and* a peer daemon claims a highest height than
    // the real chain.
    // local height is the height the local daemon is currently
    // synced to, it will be lower than the real chain height if
    // the daemon is currently syncing.
    // If we use the approximate height we subtract one month as
    // a safety margin.
    height = get_approximate_blockchain_height();
    uint64_t target_height = get_daemon_blockchain_target_height(err);
    if (err.empty()) {
      if (target_height < height)
        height = target_height;
    } else {
      // if we couldn't talk to the daemon, check safety margin.
      if (height > blocks_per_month)
        height -= blocks_per_month;
      else
        height = 0;
    }
    uint64_t local_height = get_daemon_blockchain_height(err);
    if (err.empty() && local_height > height)
      height = local_height;
    return height;
  }

◆ exchange_multisig_keys() [1/2]

std::string tools::wallet2::exchange_multisig_keys	(	const epee::wipeable_string &	password,
		const std::vector< std::string > &	info
	)

Definition at line 5170 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(info.empty(),
     error::wallet_internal_error, "Empty multisig info");
  
   if (info[0].substr(0, MULTISIG_EXTRA_INFO_MAGIC.size()) != MULTISIG_EXTRA_INFO_MAGIC)
   {
     THROW_WALLET_EXCEPTION_IF(false,
       error::wallet_internal_error, "Unsupported info string");
   }
  
   std::vector<crypto::public_key> signers;
   std::unordered_set<crypto::public_key> pkeys;
  
   THROW_WALLET_EXCEPTION_IF(!unpack_extra_multisig_info(info, signers, pkeys),
     error::wallet_internal_error, "Bad extra multisig info");
  
   return exchange_multisig_keys(password, pkeys, signers);
 }

◆ exchange_multisig_keys() [2/2]

std::string tools::wallet2::exchange_multisig_keys	(	const epee::wipeable_string &	password,
		std::unordered_set< crypto::public_key >	pkeys,
		std::vector< crypto::public_key >	signers
	)

Any but first round of keys exchange.

Definition at line 5191 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(!derivations.empty(), "empty pkeys");
   CHECK_AND_ASSERT_THROW_MES(!signers.empty(), "empty signers");
  
   bool ready = false;
   CHECK_AND_ASSERT_THROW_MES(multisig(&ready), "The wallet is not multisig");
   CHECK_AND_ASSERT_THROW_MES(!ready, "Multisig wallet creation process has already been finished");
  
   // keys are decrypted
   epee::misc_utils::auto_scope_leave_caller keys_reencryptor;
   if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
   {
     crypto::chacha_key chacha_key;
     crypto::generate_chacha_key(password.data(), password.size(), chacha_key, m_kdf_rounds);
     m_account.encrypt_viewkey(chacha_key);
     m_account.decrypt_keys(chacha_key);
     keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this, chacha_key]() { m_account.encrypt_keys(chacha_key); m_account.decrypt_viewkey(chacha_key); });
   }
  
   if (m_multisig_rounds_passed == multisig_rounds_required(m_multisig_signers.size(), m_multisig_threshold) - 1)
   {
     // the last round is passed and we have to calculate spend public key
     // add ours if not included
     crypto::public_key local_signer = get_multisig_signer_public_key();
  
     if (std::find(signers.begin(), signers.end(), local_signer) == signers.end())
     {
         signers.push_back(local_signer);
         for (const auto &msk: get_account().get_multisig_keys())
         {
             derivations.insert(rct::rct2pk(rct::scalarmultBase(rct::sk2rct(msk))));
         }
     }
  
     CHECK_AND_ASSERT_THROW_MES(signers.size() == m_multisig_signers.size(), "Bad signers size");
  
     // Summing all of unique public multisig keys to calculate common public spend key
     crypto::public_key spend_public_key = cryptonote::generate_multisig_M_N_spend_public_key(std::vector<crypto::public_key>(derivations.begin(), derivations.end()));
     m_account_public_address.m_spend_public_key = spend_public_key;
     m_account.finalize_multisig(spend_public_key);
  
     m_multisig_signers = signers;
     std::sort(m_multisig_signers.begin(), m_multisig_signers.end(), [](const crypto::public_key &e0, const crypto::public_key &e1){ return memcmp(&e0, &e1, sizeof(e0)); });
  
     ++m_multisig_rounds_passed;
     m_multisig_derivations.clear();
  
     // keys are encrypted again
     keys_reencryptor = epee::misc_utils::auto_scope_leave_caller();
  
     if (!m_wallet_file.empty())
     {
       bool r = store_keys(m_keys_file, password, false);
       THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
  
       if (boost::filesystem::exists(m_wallet_file + ".address.txt"))
       {
         r = file_io_utils::save_string_to_file(m_wallet_file + ".address.txt", m_account.get_public_address_str(m_nettype));
         if(!r) MERROR("String with address text not saved");
       }
     }
  
     m_subaddresses.clear();
     m_subaddress_labels.clear();
     add_subaddress_account(tr("Primary account"));
  
     if (!m_wallet_file.empty())
       store();
  
     return {};
   }
  
   // Below are either middle or secret spend key establishment rounds
  
   for (const auto& key: m_multisig_derivations)
     derivations.erase(key);
  
   // Deriving multisig keys (set of Mi = b * Bi) according to DH from other participants' multisig keys.
   auto new_derivations = cryptonote::generate_multisig_derivations(get_account().get_keys(), std::vector<crypto::public_key>(derivations.begin(), derivations.end()));
  
   std::string extra_multisig_info;
   if (m_multisig_rounds_passed == multisig_rounds_required(m_multisig_signers.size(), m_multisig_threshold) - 2) // next round is last
   {
     // Next round is last therefore we are performing secret spend establishment round as described above.
     MINFO("Creating spend key...");
  
     // Calculating our secret multisig keys by hashing our public multisig keys.
     auto multisig_keys = cryptonote::calculate_multisig_keys(std::vector<crypto::public_key>(new_derivations.begin(), new_derivations.end()));
     // And summing it to get personal secret spend key
     crypto::secret_key spend_skey = cryptonote::calculate_multisig_signer_key(multisig_keys);
  
     m_account.make_multisig(m_account.get_keys().m_view_secret_key, spend_skey, rct::rct2pk(rct::identity()), multisig_keys);
  
     // Packing public multisig keys to exchange with others and calculate common public spend key in the last round
     extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, secret_keys_to_public_keys(multisig_keys), spend_skey);
   }
   else
   {
     // This is just middle round
     MINFO("Preparing keys for next exchange round...");
     extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, new_derivations, m_account.get_keys().m_spend_secret_key);
     m_multisig_derivations = new_derivations;
   }
  
   ++m_multisig_rounds_passed;
  
   create_keys_file(m_wallet_file, false, password, boost::filesystem::exists(m_wallet_file + ".address.txt"));
   return extra_multisig_info;
 }

◆ expand_subaddresses()

void tools::wallet2::expand_subaddresses	(	const cryptonote::subaddress_index &	index,
		const bool	udpate_account_tags = `true`
	)

Definition at line 1477 of file wallet2.cpp.

 {
   hw::device &hwdev = m_account.get_device();
   if (m_subaddress_labels.size() <= index.major)
   {
     // add new accounts
     cryptonote::subaddress_index index2;
     const uint32_t major_end = get_subaddress_clamped_sum(index.major, m_subaddress_lookahead_major);
     for (index2.major = m_subaddress_labels.size(); index2.major < major_end; ++index2.major)
     {
       const uint32_t end = get_subaddress_clamped_sum((index2.major == index.major ? index.minor : 0), m_subaddress_lookahead_minor);
       const std::vector<crypto::public_key> pkeys = hwdev.get_subaddress_spend_public_keys(m_account.get_keys(), index2.major + (index2.major != 0 ? m_account_major_offset : 0), 0, end);
       for (index2.minor = 0; index2.minor < end; ++index2.minor)
       {
          const crypto::public_key &D = pkeys[index2.minor];
          m_subaddresses[D] = index2;
       }
     }
     m_subaddress_labels.resize(index.major + 1, {"Untitled account"});
     m_subaddress_labels[index.major].resize(index.minor + 1);
  
     if(update_account_tags)
       get_account_tags();
   }
   else if (m_subaddress_labels[index.major].size() <= index.minor)
   {
     // add new subaddresses
     const uint32_t end = get_subaddress_clamped_sum(index.minor, m_subaddress_lookahead_minor);
     const uint32_t begin = m_subaddress_labels[index.major].size();
     cryptonote::subaddress_index index2 = {index.major, begin};
     const std::vector<crypto::public_key> pkeys = hwdev.get_subaddress_spend_public_keys(m_account.get_keys(), index2.major + (index2.major != 0 ? m_account_major_offset : 0), index2.minor, end);
     for (; index2.minor < end; ++index2.minor)
     {
        const crypto::public_key &D = pkeys[index2.minor - begin];
        m_subaddresses[D] = index2;
     }
     m_subaddress_labels[index.major].resize(index.minor + 1);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ explicit_refresh_from_block_height() [1/2]

bool tools::wallet2::explicit_refresh_from_block_height ( ) const

inline

Definition at line 740 of file wallet2.h.

740 {return m_explicit_refresh_from_block_height;}

◆ explicit_refresh_from_block_height() [2/2]

void tools::wallet2::explicit_refresh_from_block_height ( bool expl )

inline

Definition at line 739 of file wallet2.h.

739 {m_explicit_refresh_from_block_height = expl;}

◆ export_blockchain()

std::tuple< size_t, crypto::hash, std::vector< crypto::hash > > tools::wallet2::export_blockchain ( ) const

Definition at line 12471 of file wallet2.cpp.

 {
   std::tuple<size_t, crypto::hash, std::vector<crypto::hash>> bc;
   std::get<0>(bc) = m_blockchain.offset();
   std::get<1>(bc) = m_blockchain.empty() ? crypto::null_hash: m_blockchain.genesis();
   for (size_t n = m_blockchain.offset(); n < m_blockchain.size(); ++n)
   {
     std::get<2>(bc).push_back(m_blockchain[n]);
   }
   return bc;
 }

◆ export_key_images() [1/2]

std::pair< size_t, std::vector< std::pair< crypto::key_image, crypto::signature > > > tools::wallet2::export_key_images ( bool all = false ) const

Definition at line 12011 of file wallet2.cpp.

 {
   PERF_TIMER(export_key_images_raw);
   std::vector<std::pair<crypto::key_image, crypto::signature>> ski;
  
   size_t offset = 0;
   if (!all)
   {
     while (offset < m_transfers.size() && !m_transfers[offset].m_key_image_request)
       ++offset;
   }
  
   ski.reserve(m_transfers.size() - offset);
   for (size_t n = offset; n < m_transfers.size(); ++n)
   {
     const transfer_details &td = m_transfers[n];
  
     // get ephemeral public key
     const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
     THROW_WALLET_EXCEPTION_IF(out.target.type() != typeid(txout_to_key), error::wallet_internal_error,
         "Output is not txout_to_key");
     const cryptonote::txout_to_key &o = boost::get<const cryptonote::txout_to_key>(out.target);
     const crypto::public_key pkey = o.key;
  
     // get tx pub key
     std::vector<tx_extra_field> tx_extra_fields;
     if(!parse_tx_extra(td.m_tx.extra, tx_extra_fields))
     {
       // Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
     }
  
     crypto::public_key tx_pub_key = get_tx_pub_key_from_received_outs(td);
     const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
  
     // generate ephemeral secret key
     crypto::key_image ki;
     cryptonote::keypair in_ephemeral;
     bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, pkey, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, ki, m_account.get_device(), m_account_major_offset);
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
  
     THROW_WALLET_EXCEPTION_IF(td.m_key_image_known && !td.m_key_image_partial && ki != td.m_key_image,
         error::wallet_internal_error, "key_image generated not matched with cached key image");
     THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != pkey,
         error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key");
  
     // sign the key image with the output secret key
     crypto::signature signature;
     std::vector<const crypto::public_key*> key_ptrs;
     key_ptrs.push_back(&pkey);
  
     crypto::generate_ring_signature((const crypto::hash&)td.m_key_image, td.m_key_image, key_ptrs, in_ephemeral.sec, 0, &signature);
  
     ski.push_back(std::make_pair(td.m_key_image, signature));
   }
   return std::make_pair(offset, ski);
 }

Here is the call graph for this function:

◆ export_key_images() [2/2]

bool tools::wallet2::export_key_images ( const std::string & filename ) const

Definition at line 11981 of file wallet2.cpp.

 {
   PERF_TIMER(export_key_images);
   std::pair<size_t, std::vector<std::pair<crypto::key_image, crypto::signature>>> ski = export_key_images();
   std::string magic(KEY_IMAGE_EXPORT_FILE_MAGIC, strlen(KEY_IMAGE_EXPORT_FILE_MAGIC));
   const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
   const uint32_t offset = ski.first;
  
   std::string data;
   data.reserve(4 + ski.second.size() * (sizeof(crypto::key_image) + sizeof(crypto::signature)) + 2 * sizeof(crypto::public_key));
   data.resize(4);
   data[0] = offset & 0xff;
   data[1] = (offset >> 8) & 0xff;
   data[2] = (offset >> 16) & 0xff;
   data[3] = (offset >> 24) & 0xff;
   data += std::string((const char *)&keys.m_spend_public_key, sizeof(crypto::public_key));
   data += std::string((const char *)&keys.m_view_public_key, sizeof(crypto::public_key));
   for (const auto &i: ski.second)
   {
     data += std::string((const char *)&i.first, sizeof(crypto::key_image));
     data += std::string((const char *)&i.second, sizeof(crypto::signature));
   }
  
   // encrypt data, keep magic plaintext
   PERF_TIMER(export_key_images_encrypt);
   std::string ciphertext = encrypt_with_view_secret_key(data);
   return epee::file_io_utils::save_string_to_file(filename, magic + ciphertext);    
 }

Here is the call graph for this function:

◆ export_multisig()

cryptonote::blobdata tools::wallet2::export_multisig ( )

Export multisig info This will generate and remember new k values

Definition at line 12774 of file wallet2.cpp.

 {
   std::vector<tools::wallet2::multisig_info> info;
  
   const crypto::public_key signer = get_multisig_signer_public_key();
  
   info.resize(m_transfers.size());
   for (size_t n = 0; n < m_transfers.size(); ++n)
   {
     transfer_details &td = m_transfers[n];
     crypto::key_image ki;
     td.m_multisig_k.clear();
     info[n].m_LR.clear();
     info[n].m_partial_key_images.clear();
  
     for (size_t m = 0; m < get_account().get_multisig_keys().size(); ++m)
     {
       // we want to export the partial key image, not the full one, so we can't use td.m_key_image
       bool r = generate_multisig_key_image(get_account().get_keys(), m, td.get_public_key(), ki);
       CHECK_AND_ASSERT_THROW_MES(r, "Failed to generate key image");
       info[n].m_partial_key_images.push_back(ki);
     }
  
     // Wallet tries to create as many transactions as many signers combinations. We calculate the maximum number here as follows:
     // if we have 2/4 wallet with signers: A, B, C, D and A is a transaction creator it will need to pick up 1 signer from 3 wallets left.
     // That means counting combinations for excluding 2-of-3 wallets (k = total signers count - threshold, n = total signers count - 1).
     size_t nlr = tools::combinations_count(m_multisig_signers.size() - m_multisig_threshold, m_multisig_signers.size() - 1);
     for (size_t m = 0; m < nlr; ++m)
     {
       td.m_multisig_k.push_back(rct::skGen());
       const rct::multisig_kLRki kLRki = get_multisig_kLRki(n, td.m_multisig_k.back());
       info[n].m_LR.push_back({kLRki.L, kLRki.R});
     }
  
     info[n].m_signer = signer;
   }
  
   std::stringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   ar << info;
  
   const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
   std::string header;
   header += std::string((const char *)&keys.m_spend_public_key, sizeof(crypto::public_key));
   header += std::string((const char *)&keys.m_view_public_key, sizeof(crypto::public_key));
   header += std::string((const char *)&signer, sizeof(crypto::public_key));
   std::string ciphertext = encrypt_with_view_secret_key(header + oss.str());
  
   return MULTISIG_EXPORT_FILE_MAGIC + ciphertext;
 }

Here is the call graph for this function:

◆ export_outputs()

std::pair< size_t, std::vector< tools::wallet2::transfer_details > > tools::wallet2::export_outputs ( bool all = false ) const

Definition at line 12503 of file wallet2.cpp.

 {
   PERF_TIMER(export_outputs);
   std::vector<tools::wallet2::transfer_details> outs;
  
   size_t offset = 0;
   if (!all)
     while (offset < m_transfers.size() && (m_transfers[offset].m_key_image_known && !m_transfers[offset].m_key_image_request))
       ++offset;
  
   outs.reserve(m_transfers.size() - offset);
   for (size_t n = offset; n < m_transfers.size(); ++n)
   {
     const transfer_details &td = m_transfers[n];
  
     outs.push_back(td);
   }
  
   return std::make_pair(offset, outs);
 }

◆ export_outputs_to_str()

std::string tools::wallet2::export_outputs_to_str ( bool all = false ) const

Definition at line 12524 of file wallet2.cpp.

 {
   PERF_TIMER(export_outputs_to_str);
  
   std::stringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   const auto& outputs = export_outputs(all);
   ar << outputs;
  
   std::string magic(OUTPUT_EXPORT_FILE_MAGIC, strlen(OUTPUT_EXPORT_FILE_MAGIC));
   const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
   std::string header;
   header += std::string((const char *)&keys.m_spend_public_key, sizeof(crypto::public_key));
   header += std::string((const char *)&keys.m_view_public_key, sizeof(crypto::public_key));
   PERF_TIMER(export_outputs_encryption);
   std::string ciphertext = encrypt_with_view_secret_key(header + oss.str());
   return magic + ciphertext;
 }

◆ export_payments()

wallet2::payment_container tools::wallet2::export_payments ( ) const

Definition at line 12445 of file wallet2.cpp.

 {
   payment_container payments;
   for (auto const &p : m_payments)
   {
     payments.emplace(p);
   }
   return payments;
 }

◆ finalize_multisig() [1/2]

bool tools::wallet2::finalize_multisig	(	const epee::wipeable_string &	password,
		const std::unordered_set< crypto::public_key > &	pkeys,
		std::vector< crypto::public_key >	signers
	)

Finalizes creation of a multisig wallet.

Definition at line 5366 of file wallet2.cpp.

 {
   bool ready;
   uint32_t threshold, total;
   if (!multisig(&ready, &threshold, &total))
   {
     MERROR("This is not a multisig wallet");
     return false;
   }
   if (ready)
   {
     MERROR("This multisig wallet is already finalized");
     return false;
   }
   if (threshold + 1 != total)
   {
     MERROR("finalize_multisig should only be used for N-1/N wallets, use exchange_multisig_keys instead");
     return false;
   }
   exchange_multisig_keys(password, pkeys, signers);
   return true;
 }

◆ finalize_multisig() [2/2]

bool tools::wallet2::finalize_multisig	(	const epee::wipeable_string &	password,
		const std::vector< std::string > &	info
	)

Finalizes creation of a multisig wallet.

Definition at line 5406 of file wallet2.cpp.

 {
   std::unordered_set<crypto::public_key> public_keys;
   std::vector<crypto::public_key> signers;
   if (!unpack_extra_multisig_info(info, signers, public_keys))
   {
     MERROR("Bad multisig info");
     return false;
   }
  
   return finalize_multisig(password, public_keys, signers);
 }

◆ find_and_save_rings()

bool tools::wallet2::find_and_save_rings ( bool force = true )

Definition at line 7899 of file wallet2.cpp.

 {
   if (!force && m_ring_history_saved)
     return true;
   if (!m_ringdb)
     return false;
  
   COMMAND_RPC_GET_TRANSACTIONS::request req = AUTO_VAL_INIT(req);
   COMMAND_RPC_GET_TRANSACTIONS::response res = AUTO_VAL_INIT(res);
  
   MDEBUG("Finding and saving rings...");
  
   // get payments we made
   std::vector<crypto::hash> txs_hashes;
   std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>> payments;
   get_payments_out(payments, 0, std::numeric_limits<uint64_t>::max(), boost::none, std::set<uint32_t>());
   for (const std::pair<crypto::hash,wallet2::confirmed_transfer_details> &entry: payments)
   {
     const crypto::hash &txid = entry.first;
     txs_hashes.push_back(txid);
   }
  
   MDEBUG("Found " << std::to_string(txs_hashes.size()) << " transactions");
  
   // get those transactions from the daemon
   auto it = txs_hashes.begin();
   static const size_t SLICE_SIZE = 200;
   for (size_t slice = 0; slice < txs_hashes.size(); slice += SLICE_SIZE)
   {
     req.decode_as_json = false;
     req.prune = true;
     req.txs_hashes.clear();
     size_t ntxes = slice + SLICE_SIZE > txs_hashes.size() ? txs_hashes.size() - slice : SLICE_SIZE;
     for (size_t s = slice; s < slice + ntxes; ++s)
       req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txs_hashes[s]));
     bool r;
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
       r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
     }
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
     THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
     THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
     THROW_WALLET_EXCEPTION_IF(res.txs.size() != req.txs_hashes.size(), error::wallet_internal_error,
       "daemon returned wrong response for gettransactions, wrong txs count = " +
       std::to_string(res.txs.size()) + ", expected " + std::to_string(req.txs_hashes.size()));
  
     MDEBUG("Scanning " << res.txs.size() << " transactions");
     THROW_WALLET_EXCEPTION_IF(slice + res.txs.size() > txs_hashes.size(), error::wallet_internal_error, "Unexpected tx array size");
     for (size_t i = 0; i < res.txs.size(); ++i, ++it)
     {
     const auto &tx_info = res.txs[i];
       cryptonote::transaction tx;
       crypto::hash tx_hash;
       THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(tx_info, tx, tx_hash), error::wallet_internal_error,
           "Failed to get transaction from daemon");
       THROW_WALLET_EXCEPTION_IF(!(tx_hash == *it), error::wallet_internal_error, "Wrong txid received");
       THROW_WALLET_EXCEPTION_IF(!add_rings(get_ringdb_key(), tx), error::wallet_internal_error, "Failed to save ring");
     }
   }
  
   MINFO("Found and saved rings for " << txs_hashes.size() << " transactions");
   m_ring_history_saved = true;
   return true;
 }

Here is the call graph for this function:

◆ finish_rescan_bc_keep_key_images()

void tools::wallet2::finish_rescan_bc_keep_key_images	(	uint64_t	transfer_height,
		const crypto::hash &	hash
	)

Definition at line 13514 of file wallet2.cpp.

 {
   // Compute hash of m_transfers, if differs there had to be BC reorg.
   crypto::hash new_transfers_hash{};
   hash_m_transfers((int64_t) transfer_height, new_transfers_hash);
  
   if (new_transfers_hash != hash)
   {
     // Soft-Reset to avoid inconsistency in case of BC reorg.
     clear_soft(false);  // keep_key_images works only with soft reset.
     THROW_WALLET_EXCEPTION_IF(true, error::wallet_internal_error, "Transfers changed during rescan, soft or hard rescan is needed");
   }
  
   // Restore key images in m_transfers from m_key_images
   for(auto it = m_key_images.begin(); it != m_key_images.end(); it++)
   {
     THROW_WALLET_EXCEPTION_IF(it->second >= m_transfers.size(), error::wallet_internal_error, "Key images cache contains illegal transfer offset");
     m_transfers[it->second].m_key_image = it->first;
     m_transfers[it->second].m_key_image_known = true;
   }
 }

◆ freeze() [1/2]

void tools::wallet2::freeze ( const crypto::key_image & ki )

Definition at line 1604 of file wallet2.cpp.

 {
   freeze(get_transfer_details(ki));
 }

Here is the call graph for this function:

◆ freeze() [2/2]

void tools::wallet2::freeze ( size_t idx )

Definition at line 1583 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "Invalid transfer_details index");
   transfer_details &td = m_transfers[idx];
   td.m_frozen = true;
 }

Here is the caller graph for this function:

◆ frozen() [1/3]

bool tools::wallet2::frozen ( const crypto::key_image & ki ) const

Definition at line 1614 of file wallet2.cpp.

 {
   return frozen(get_transfer_details(ki));
 }

Here is the call graph for this function:

◆ frozen() [2/3]

bool tools::wallet2::frozen ( const transfer_details & td ) const

Definition at line 1630 of file wallet2.cpp.

 {
   return td.m_frozen;
 }

◆ frozen() [3/3]

bool tools::wallet2::frozen ( size_t idx ) const

Definition at line 1597 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "Invalid transfer_details index");
   const transfer_details &td = m_transfers[idx];
   return td.m_frozen;
 }

Here is the caller graph for this function:

◆ generate() [1/4]

crypto::secret_key tools::wallet2::generate	(	const std::string &	wallet_,
		const epee::wipeable_string &	password,
		const crypto::secret_key &	recovery_param = `crypto::secret_key()`,
		bool	recover = `false`,
		bool	two_random = `false`,
		bool	create_address_file = `false`
	)

Generates a wallet or restores one.

Parameters

wallet_	Name of wallet file
password	Password of wallet file
recovery_param	If it is a restore, the recovery key
recover	Whether it is a restore
two_random	Whether it is a non-deterministic wallet
create_address_file	Whether to create an address file

Returns: The secret key of the generated wallet

Definition at line 4847 of file wallet2.cpp.

 {
   clear();
   prepare_file_names(wallet_);
  
   if (!wallet_.empty())
   {
     boost::system::error_code ignored_ec;
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
   }
  
   crypto::secret_key retval = m_account.generate(recovery_param, recover, two_random);
  
   init_type(hw::device::device_type::SOFTWARE);
   setup_keys(password);
  
   // calculate a starting refresh height
   if(m_refresh_from_block_height == 0 && !recover){
     m_refresh_from_block_height = estimate_blockchain_height();
   }
  
   create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
  
   setup_new_blockchain();
  
   if (!wallet_.empty())
     store();
  
   return retval;
 }

◆ generate() [2/4]

void tools::wallet2::generate	(	const std::string &	wallet_,
		const epee::wipeable_string &	password,
		const cryptonote::account_public_address &	account_public_address,
		const crypto::secret_key &	spendkey,
		const crypto::secret_key &	viewkey,
		bool	create_address_file = `false`
	)

Creates a wallet from a public address and a spend/view secret key pair.

Parameters

wallet_	Name of wallet file
password	Password of wallet file
account_public_address	The account's public address
spendkey	spend secret key
viewkey	view secret key
create_address_file	Whether to create an address file

Definition at line 4967 of file wallet2.cpp.

 {
   clear();
   prepare_file_names(wallet_);
  
   if (!wallet_.empty())
   {
     boost::system::error_code ignored_ec;
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
   }
  
   m_account.create_from_keys(account_public_address, spendkey, viewkey);
   init_type(hw::device::device_type::SOFTWARE);
   m_account_public_address = account_public_address;
   setup_keys(password);
  
   create_keys_file(wallet_, false, password, create_address_file);
  
   setup_new_blockchain();
  
   if (!wallet_.empty())
     store();
 }

◆ generate() [3/4]

void tools::wallet2::generate	(	const std::string &	wallet_,
		const epee::wipeable_string &	password,
		const cryptonote::account_public_address &	account_public_address,
		const crypto::secret_key &	viewkey = `crypto::secret_key()`,
		bool	create_address_file = `false`
	)

Creates a watch only wallet from a public address and a view secret key.

Parameters

wallet_	Name of wallet file
password	Password of wallet file
account_public_address	The account's public address
viewkey	view secret key
create_address_file	Whether to create an address file

Definition at line 4930 of file wallet2.cpp.

 {
   clear();
   prepare_file_names(wallet_);
  
   if (!wallet_.empty())
   {
     boost::system::error_code ignored_ec;
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
   }
  
   m_account.create_from_viewkey(account_public_address, viewkey);
   init_type(hw::device::device_type::SOFTWARE);
   m_watch_only = true;
   m_account_public_address = account_public_address;
   setup_keys(password);
  
   create_keys_file(wallet_, true, password, m_nettype != MAINNET || create_address_file);
  
   setup_new_blockchain();
  
   if (!wallet_.empty())
     store();
 }

◆ generate() [4/4]

void tools::wallet2::generate	(	const std::string &	wallet_,
		const epee::wipeable_string &	password,
		const epee::wipeable_string &	multisig_data,
		bool	create_address_file = `false`
	)

Generates a wallet or restores one.

Parameters

wallet_	Name of wallet file
password	Password of wallet file
multisig_data	The multisig restore info and keys
create_address_file	Whether to create an address file

Definition at line 4759 of file wallet2.cpp.

 {
   clear();
   prepare_file_names(wallet_);
  
   if (!wallet_.empty())
   {
     boost::system::error_code ignored_ec;
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
   }
  
   m_account.generate(rct::rct2sk(rct::zero()), true, false);
  
   THROW_WALLET_EXCEPTION_IF(multisig_data.size() < 32, error::invalid_multisig_seed);
   size_t offset = 0;
   uint32_t threshold = *(uint32_t*)(multisig_data.data() + offset);
   offset += sizeof(uint32_t);
   uint32_t total = *(uint32_t*)(multisig_data.data() + offset);
   offset += sizeof(uint32_t);
   THROW_WALLET_EXCEPTION_IF(threshold < 2, error::invalid_multisig_seed);
   THROW_WALLET_EXCEPTION_IF(total != threshold && total != threshold + 1, error::invalid_multisig_seed);
   const size_t n_multisig_keys =  total == threshold ? 1 : threshold;
   THROW_WALLET_EXCEPTION_IF(multisig_data.size() != 8 + 32 * (4 + n_multisig_keys + total), error::invalid_multisig_seed);
  
   std::vector<crypto::secret_key> multisig_keys;
   std::vector<crypto::public_key> multisig_signers;
   crypto::secret_key spend_secret_key = *(crypto::secret_key*)(multisig_data.data() + offset);
   offset += sizeof(crypto::secret_key);
   crypto::public_key spend_public_key = *(crypto::public_key*)(multisig_data.data() + offset);
   offset += sizeof(crypto::public_key);
   crypto::secret_key view_secret_key = *(crypto::secret_key*)(multisig_data.data() + offset);
   offset += sizeof(crypto::secret_key);
   crypto::public_key view_public_key = *(crypto::public_key*)(multisig_data.data() + offset);
   offset += sizeof(crypto::public_key);
   for (size_t n = 0; n < n_multisig_keys; ++n)
   {
     multisig_keys.push_back(*(crypto::secret_key*)(multisig_data.data() + offset));
     offset += sizeof(crypto::secret_key);
   }
   for (size_t n = 0; n < total; ++n)
   {
     multisig_signers.push_back(*(crypto::public_key*)(multisig_data.data() + offset));
     offset += sizeof(crypto::public_key);
   }
  
   crypto::public_key calculated_view_public_key;
   THROW_WALLET_EXCEPTION_IF(!crypto::secret_key_to_public_key(view_secret_key, calculated_view_public_key), error::invalid_multisig_seed);
   THROW_WALLET_EXCEPTION_IF(view_public_key != calculated_view_public_key, error::invalid_multisig_seed);
   crypto::public_key local_signer;
   THROW_WALLET_EXCEPTION_IF(!crypto::secret_key_to_public_key(spend_secret_key, local_signer), error::invalid_multisig_seed);
   THROW_WALLET_EXCEPTION_IF(std::find(multisig_signers.begin(), multisig_signers.end(), local_signer) == multisig_signers.end(), error::invalid_multisig_seed);
   rct::key skey = rct::zero();
   for (const auto &msk: multisig_keys)
     sc_add(skey.bytes, skey.bytes, rct::sk2rct(msk).bytes);
   THROW_WALLET_EXCEPTION_IF(!(rct::rct2sk(skey) == spend_secret_key), error::invalid_multisig_seed);
   memwipe(&skey, sizeof(rct::key));
  
   m_account.make_multisig(view_secret_key, spend_secret_key, spend_public_key, multisig_keys);
   m_account.finalize_multisig(spend_public_key);
  
   // Not possible to restore a multisig wallet that is able to activate the MMS
   // (because the original keys are not (yet) part of the restore info), so
   // keep m_original_keys_available to false
   init_type(hw::device::device_type::SOFTWARE);
   m_multisig = true;
   m_multisig_threshold = threshold;
   m_multisig_signers = multisig_signers;
   setup_keys(password);
  
   create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
   setup_new_blockchain();
  
   if (!wallet_.empty())
     store();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_account() [1/2]

cryptonote::account_base& tools::wallet2::get_account ( )

inline

Definition at line 728 of file wallet2.h.

728 {return m_account;}

Here is the caller graph for this function:

◆ get_account() [2/2]

const cryptonote::account_base& tools::wallet2::get_account ( ) const

inline

Definition at line 729 of file wallet2.h.

729 {return m_account;}

◆ get_account_tags()

const std::pair< std::map< std::string, std::string >, std::vector< std::string > > & tools::wallet2::get_account_tags ( )

Get the list of registered account tags.

Returns: first.Key=(tag's name), first.Value=(tag's label), second[i]=(i-th account's tag)

Definition at line 11826 of file wallet2.cpp.

 {
   // ensure consistency
   if (m_account_tags.second.size() != get_num_subaddress_accounts())
     m_account_tags.second.resize(get_num_subaddress_accounts(), "");
   for (const std::string& tag : m_account_tags.second)
   {
     if (!tag.empty() && m_account_tags.first.count(tag) == 0)
       m_account_tags.first.insert({tag, ""});
   }
   for (auto i = m_account_tags.first.begin(); i != m_account_tags.first.end(); )
   {
     if (std::find(m_account_tags.second.begin(), m_account_tags.second.end(), i->first) == m_account_tags.second.end())
       i = m_account_tags.first.erase(i);
     else
       ++i;
   }
   return m_account_tags;
 }

Here is the caller graph for this function:

◆ get_address()

cryptonote::account_public_address tools::wallet2::get_address ( ) const

inline

Definition at line 787 of file wallet2.h.

787 { return get_subaddress({0,0}); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_address_as_str()

std::string tools::wallet2::get_address_as_str ( ) const

inline

Definition at line 792 of file wallet2.h.

792 { return get_subaddress_as_str({0, 0}); }

tools::wallet2::get_subaddress_as_str

std::string get_subaddress_as_str(const cryptonote::subaddress_index &index) const

Definition: wallet2.cpp:1451

Here is the call graph for this function:

◆ get_address_book()

std::vector<address_book_row> tools::wallet2::get_address_book ( ) const

inline

GUI Address book get/store.

Definition at line 1142 of file wallet2.h.

1142 { return m_address_book; }

◆ get_approximate_blockchain_height()

uint64_t tools::wallet2::get_approximate_blockchain_height ( ) const

Calculates the approximate blockchain height from current date/time.

Definition at line 11755 of file wallet2.cpp.

 {
   // time of v2 fork
   const time_t fork_time = m_nettype == TESTNET ? 1341378000 : m_nettype == STAGENET ? 1521000000 : 1538815057;
   // v2 fork block
   const uint64_t fork_block = m_nettype == TESTNET ? 190060 : m_nettype == STAGENET ? 32000 : 307500;
   // avg seconds per block
   const int seconds_per_block = DIFFICULTY_TARGET_V6;
   // Calculated blockchain height
   uint64_t approx_blockchain_height = fork_block + (time(NULL) - fork_time)/seconds_per_block;
   // testnet got some huge rollbacks, so the estimation is way off
   static const uint64_t approximate_testnet_rolled_back_blocks = 303967;
   if (m_nettype == TESTNET && approx_blockchain_height > approximate_testnet_rolled_back_blocks)
     approx_blockchain_height -= approximate_testnet_rolled_back_blocks;
   // estiamte blocks from v6
   if(m_nettype == MAINNET) {
     approx_blockchain_height += 82000;
   }
   LOG_PRINT_L2("Calculated blockchain height: " << approx_blockchain_height);
   return approx_blockchain_height;
 }

◆ get_attribute()

std::string tools::wallet2::get_attribute ( const std::string & key ) const

Definition at line 11808 of file wallet2.cpp.

 {
   std::unordered_map<std::string, std::string>::const_iterator i = m_attributes.find(key);
   if (i == m_attributes.end())
     return std::string();
   return i->second;
 }

◆ get_base_fee()

uint64_t tools::wallet2::get_base_fee ( ) const

Definition at line 7584 of file wallet2.cpp.

 {
   if(m_light_wallet)
   {
     if (use_fork_rules(HF_VERSION_PER_BYTE_FEE))
       return m_light_wallet_per_kb_fee / 1024;
     else
       return m_light_wallet_per_kb_fee;
   }
   bool use_dyn_fee = use_fork_rules(HF_VERSION_DYNAMIC_FEE, -720 * 1);
   if (!use_dyn_fee)
     return FEE_PER_KB_V6;
  
   return get_dynamic_base_fee_estimate();
 }

◆ get_blockchain_current_height()

uint64_t tools::wallet2::get_blockchain_current_height ( ) const

inline

Definition at line 890 of file wallet2.h.

890 { return m_light_wallet_blockchain_height ? m_light_wallet_blockchain_height : m_blockchain.size(); }

Here is the caller graph for this function:

◆ get_blockchain_height_by_date()

uint64_t tools::wallet2::get_blockchain_height_by_date	(	uint16_t	year,
		uint8_t	month,
		uint8_t	day
	)

Definition at line 13173 of file wallet2.cpp.

 {
   uint32_t version;
   if (!check_connection(&version))
   {
     throw std::runtime_error("failed to connect to daemon: " + get_daemon_address());
   }
   if (version < MAKE_CORE_RPC_VERSION(1, 6))
   {
     throw std::runtime_error("this function requires RPC version 1.6 or higher");
   }
   std::tm date = { 0, 0, 0, 0, 0, 0, 0, 0 };
   date.tm_year = year - 1900;
   date.tm_mon  = month - 1;
   date.tm_mday = day;
   if (date.tm_mon < 0 || 11 < date.tm_mon || date.tm_mday < 1 || 31 < date.tm_mday)
   {
     throw std::runtime_error("month or day out of range");
   }
   uint64_t timestamp_target = std::mktime(&date);
   std::string err;
   uint64_t height_min = 0;
   uint64_t height_max = get_daemon_blockchain_height(err) - 1;
   if (!err.empty())
   {
     throw std::runtime_error("failed to get blockchain height");
   }
   while (true)
   {
     COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::request req;
     COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::response res;
     uint64_t height_mid = (height_min + height_max) / 2;
     req.heights =
     {
       height_min,
       height_mid,
       height_max
     };
     bool r = invoke_http_bin("/getblocks_by_height.bin", req, res, rpc_timeout);
     if (!r || res.status != CORE_RPC_STATUS_OK)
     {
       std::ostringstream oss;
       oss << "failed to get blocks by heights: ";
       for (auto height : req.heights)
         oss << height << ' ';
       oss << endl << "reason: ";
       if (!r)
         oss << "possibly lost connection to daemon";
       else if (res.status == CORE_RPC_STATUS_BUSY)
         oss << "daemon is busy";
       else
         oss << get_rpc_status(res.status);
       throw std::runtime_error(oss.str());
     }
     cryptonote::block blk_min, blk_mid, blk_max;
     if (res.blocks.size() < 3) throw std::runtime_error("Not enough blocks returned from daemon");
     if (!parse_and_validate_block_from_blob(res.blocks[0].block, blk_min)) throw std::runtime_error("failed to parse blob at height " + std::to_string(height_min));
     if (!parse_and_validate_block_from_blob(res.blocks[1].block, blk_mid)) throw std::runtime_error("failed to parse blob at height " + std::to_string(height_mid));
     if (!parse_and_validate_block_from_blob(res.blocks[2].block, blk_max)) throw std::runtime_error("failed to parse blob at height " + std::to_string(height_max));
     uint64_t timestamp_min = blk_min.timestamp;
     uint64_t timestamp_mid = blk_mid.timestamp;
     uint64_t timestamp_max = blk_max.timestamp;
     if (!(timestamp_min <= timestamp_mid && timestamp_mid <= timestamp_max))
     {
       // the timestamps are not in the chronological order.
       // assuming they're sufficiently close to each other, simply return the smallest height
       return std::min({height_min, height_mid, height_max});
     }
     if (timestamp_target > timestamp_max)
     {
       throw std::runtime_error("specified date is in the future");
     }
     if (timestamp_target <= timestamp_min + 2 * 24 * 60 * 60)   // two days of "buffer" period
     {
       return height_min;
     }
     if (timestamp_target <= timestamp_mid)
       height_max = height_mid;
     else
       height_min = height_mid;
     if (height_max - height_min <= 2 * 24 * 30)        // don't divide the height range finer than two days
     {
       return height_min;
     }
   }
 }

Here is the call graph for this function:

◆ get_bytes_received()

uint64_t tools::wallet2::get_bytes_received ( ) const

Definition at line 13541 of file wallet2.cpp.

 {
   return m_http_client.get_bytes_received();
 }

◆ get_bytes_sent()

uint64_t tools::wallet2::get_bytes_sent ( ) const

Definition at line 13536 of file wallet2.cpp.

 {
   return m_http_client.get_bytes_sent();
 }

◆ get_confirm_backlog_threshold()

uint32_t tools::wallet2::get_confirm_backlog_threshold ( ) const

inline

Definition at line 1082 of file wallet2.h.

1082 { return m_confirm_backlog_threshold; };

◆ get_daemon_address()

std::string tools::wallet2::get_daemon_address ( ) const

Definition at line 11716 of file wallet2.cpp.

 {
   return m_daemon_address;
 }

Here is the caller graph for this function:

◆ get_daemon_blockchain_height()

uint64_t tools::wallet2::get_daemon_blockchain_height ( std::string & err ) const

Definition at line 11721 of file wallet2.cpp.

 {
   uint64_t height;
  
   boost::optional<std::string> result = m_node_rpc_proxy.get_height(height);
   if (result)
   {
     if (m_trusted_daemon)
       err = *result;
     else
       err = "daemon error";
     return 0;
   }
  
   err = "";
   return height;
 }

◆ get_daemon_blockchain_target_height()

uint64_t tools::wallet2::get_daemon_blockchain_target_height ( std::string & err )

Definition at line 11739 of file wallet2.cpp.

 {
   err = "";
   uint64_t target_height = 0;
   const auto result = m_node_rpc_proxy.get_target_height(target_height);
   if (result && *result != CORE_RPC_STATUS_OK)
   {
     if (m_trusted_daemon)
       err = *result;
     else
       err = "daemon error";
     return 0;
   }
   return target_height;
 }

◆ get_daemon_login()

const boost::optional<epee::net_utils::http::login>& tools::wallet2::get_daemon_login ( ) const

inline

Definition at line 1157 of file wallet2.h.

1157 { return m_daemon_login; }

Here is the caller graph for this function:

◆ get_default_priority()

uint32_t tools::wallet2::get_default_priority ( ) const

inline

Definition at line 1065 of file wallet2.h.

1065 { return m_default_priority; }

◆ get_description()

std::string tools::wallet2::get_description ( ) const

Definition at line 11821 of file wallet2.cpp.

 {
   return get_attribute(ATTRIBUTE_DESCRIPTION);
 }

◆ get_device_last_key_image_sync()

uint64_t tools::wallet2::get_device_last_key_image_sync ( ) const

inline

Definition at line 899 of file wallet2.h.

899 { return m_device_last_key_image_sync; }

◆ get_device_type()

hw::device::device_type tools::wallet2::get_device_type ( ) const

inline

Definition at line 825 of file wallet2.h.

825 { return m_key_device_type; }

Here is the caller graph for this function:

◆ get_fee_algorithm()

int tools::wallet2::get_fee_algorithm ( ) const

Definition at line 7617 of file wallet2.cpp.

 {
   // changes at v3, v5, v8
   if (use_fork_rules(6, 0))
     return 3;
   if (use_fork_rules(5, 0))
     return 2;
   if (use_fork_rules(3, -720 * 14))
    return 1;
   return 0;
 }

◆ get_fee_multiplier()

uint64_t tools::wallet2::get_fee_multiplier	(	uint32_t	priority,
		int	fee_algorithm = `-1`
	)		const

Definition at line 7531 of file wallet2.cpp.

 {
   static const struct
   {
     size_t count;
     uint64_t multipliers[4];
   }
   multipliers[] =
   {
     { 3, {1, 2, 3} },
     { 3, {1, 20, 166} },
     { 4, {1, 4, 20, 166} },
     { 4, {1, 2, 4, 8} },
   };
  
   if (fee_algorithm == -1)
     fee_algorithm = get_fee_algorithm();
  
   // 0 -> default (here, x1 till fee algorithm 2, x4 from it)
   if (priority == 0)
     priority = m_default_priority;
   if (priority == 0)
   {
     if (fee_algorithm == 2)
       priority = 2;
     else
       priority = 1;
   }
  
   THROW_WALLET_EXCEPTION_IF(fee_algorithm < 0 || fee_algorithm > 4, error::invalid_priority);
  
   // 1 to 3/4 are allowed as priorities
   const uint32_t max_priority = multipliers[fee_algorithm].count;
   if (priority >= 1 && priority <= max_priority)
   {
     return multipliers[fee_algorithm].multipliers[priority-1];
   }
  
   THROW_WALLET_EXCEPTION_IF (false, error::invalid_priority);
   return 1;
 }

Here is the call graph for this function:

◆ get_fee_quantization_mask()

uint64_t tools::wallet2::get_fee_quantization_mask ( ) const

Definition at line 7600 of file wallet2.cpp.

 {
   if(m_light_wallet)
   {
     return 1; // TODO
   }
   bool use_per_byte_fee = use_fork_rules(HF_VERSION_PER_BYTE_FEE, 0);
   if (!use_per_byte_fee)
     return 1;
  
   uint64_t fee_quantization_mask;
   boost::optional<std::string> result = m_node_rpc_proxy.get_fee_quantization_mask(fee_quantization_mask);
   if (result)
     return 1;
   return fee_quantization_mask;
 }

◆ get_hard_fork_info()

void tools::wallet2::get_hard_fork_info	(	uint8_t	version,
		uint64_t &	earliest_height
	)		const

Definition at line 10504 of file wallet2.cpp.

 {
   boost::optional<std::string> result = m_node_rpc_proxy.get_earliest_height(version, earliest_height);
   throw_on_rpc_response_error(result, "get_hard_fork_info");
 }

◆ get_human_readable_timestamp()

static std::string tools::wallet2::get_human_readable_timestamp ( uint64_t ts )

inlinestatic

Check if wallet file path is valid format.

Parameters

file_path Wallet file path

Returns: Whether path is valid format

Definition at line 1031 of file wallet2.h.

     {
       char buffer[64];
       if (ts < 1234567890)
         return "<unknown>";
       time_t tt = ts;
       struct tm tm;
       #ifdef WIN32
       gmtime_s(&tm, &tt);
       #else
       gmtime_r(&tt, &tm);
       #endif
       uint64_t now = time(NULL);
       uint64_t diff = ts > now ? ts - now : now - ts;
       if (diff > 24*3600)
         strftime(buffer, sizeof(buffer), "%Y-%m-%d", &tm);
       else
         strftime(buffer, sizeof(buffer), "%I:%M:%S %p", &tm);
       return std::string(buffer);
 }

◆ get_integrated_address_as_str()

std::string tools::wallet2::get_integrated_address_as_str ( const crypto::hash8 & payment_id ) const

Definition at line 1457 of file wallet2.cpp.

 {
   return cryptonote::get_account_integrated_address_as_str(m_nettype, get_address(), payment_id);
 }

Here is the call graph for this function:

◆ get_keys_file()

std::string tools::wallet2::get_keys_file ( ) const

Definition at line 11711 of file wallet2.cpp.

 {
   return m_keys_file;
 }

◆ get_last_block_reward()

uint64_t tools::wallet2::get_last_block_reward ( ) const

inline

Definition at line 898 of file wallet2.h.

898 { return m_last_block_reward; }

◆ get_light_wallet_blockchain_height()

uint64_t tools::wallet2::get_light_wallet_blockchain_height ( ) const

inline

Definition at line 774 of file wallet2.h.

774 { return m_light_wallet_blockchain_height; }

◆ get_light_wallet_scanned_block_height()

uint64_t tools::wallet2::get_light_wallet_scanned_block_height ( ) const

inline

Definition at line 773 of file wallet2.h.

773 { return m_light_wallet_scanned_block_height; }

◆ get_max_ring_size()

uint64_t tools::wallet2::get_max_ring_size ( ) const

Definition at line 7644 of file wallet2.cpp.

 {
   if (use_fork_rules(HF_VERSION_MAX_RING_11, 10))
     return 11;
   if (use_fork_rules(HF_VERSION_ENFORCE_0_DECOY_TXS, 10))
     return 1;
   return 0;
 }

◆ get_message_store() [1/2]

mms::message_store& tools::wallet2::get_message_store ( )

inline

Definition at line 1359 of file wallet2.h.

1359 { return m_message_store; };

◆ get_message_store() [2/2]

const mms::message_store& tools::wallet2::get_message_store ( ) const

inline

Definition at line 1360 of file wallet2.h.

1360 { return m_message_store; };

◆ get_min_output_count()

uint32_t tools::wallet2::get_min_output_count ( ) const

inline

Definition at line 1074 of file wallet2.h.

1074 { return m_min_output_count; }

◆ get_min_output_value()

uint64_t tools::wallet2::get_min_output_value ( ) const

inline

Definition at line 1076 of file wallet2.h.

1076 { return m_min_output_value; }

◆ get_min_ring_size()

uint64_t tools::wallet2::get_min_ring_size ( ) const

Definition at line 7629 of file wallet2.cpp.

 {
   if (use_fork_rules(HF_VERSION_MIN_MIXIN_10, 10))
     return 11;
   if (use_fork_rules(HF_VERSION_MIN_MIXIN_6, 10))
     return 7;
   if (use_fork_rules(HF_VERSION_MIN_MIXIN_4, 10))
     return 5;
   if (use_fork_rules(HF_VERSION_ENFORCE_0_DECOY_TXS, 10))
     return 1;
   if (use_fork_rules(HF_VERSION_MIN_MIXIN_2, 10))
     return 3;
   return 0;
 }

◆ get_multisig_info()

std::string tools::wallet2::get_multisig_info ( ) const

Get a packaged multisig information string

Definition at line 5419 of file wallet2.cpp.

 {
   // It's a signed package of private view key and public spend key
   const crypto::secret_key skey = cryptonote::get_multisig_blinded_secret_key(get_account().get_keys().m_view_secret_key);
   const crypto::public_key pkey = get_multisig_signer_public_key(get_account().get_keys().m_spend_secret_key);
   crypto::hash hash;
  
   std::string data;
   data += std::string((const char *)&skey, sizeof(crypto::secret_key));
   data += std::string((const char *)&pkey, sizeof(crypto::public_key));
  
   data.resize(data.size() + sizeof(crypto::signature));
   crypto::cn_fast_hash(data.data(), data.size() - sizeof(signature), hash);
   crypto::signature &signature = *(crypto::signature*)&data[data.size() - sizeof(crypto::signature)];
   crypto::generate_signature(hash, pkey, get_multisig_blinded_secret_key(get_account().get_keys().m_spend_secret_key), signature);
  
   return std::string("MultisigV1") + tools::base58::encode(data);
 }

Here is the call graph for this function:

◆ get_multisig_seed()

bool tools::wallet2::get_multisig_seed	(	epee::wipeable_string &	seed,
		const epee::wipeable_string &	passphrase = `std::string()`,
		bool	raw = `true`
	)		const

Definition at line 1326 of file wallet2.cpp.

 {
   bool ready;
   uint32_t threshold, total;
   if (!multisig(&ready, &threshold, &total))
   {
     std::cout << "This is not a multisig wallet" << std::endl;
     return false;
   }
   if (!ready)
   {
     std::cout << "This multisig wallet is not yet finalized" << std::endl;
     return false;
   }
   if (!raw && seed_language.empty())
   {
     std::cout << "seed_language not set" << std::endl;
     return false;
   }
  
   crypto::secret_key skey;
   crypto::public_key pkey;
   const account_keys &keys = get_account().get_keys();
   epee::wipeable_string data;
   data.append((const char*)&threshold, sizeof(uint32_t));
   data.append((const char*)&total, sizeof(uint32_t));
   skey = keys.m_spend_secret_key;
   data.append((const char*)&skey, sizeof(skey));
   pkey = keys.m_account_address.m_spend_public_key;
   data.append((const char*)&pkey, sizeof(pkey));
   skey = keys.m_view_secret_key;
   data.append((const char*)&skey, sizeof(skey));
   pkey = keys.m_account_address.m_view_public_key;
   data.append((const char*)&pkey, sizeof(pkey));
   for (const auto &skey: keys.m_multisig_keys)
     data.append((const char*)&skey, sizeof(skey));
   for (const auto &signer: m_multisig_signers)
     data.append((const char*)&signer, sizeof(signer));
  
   if (!passphrase.empty())
   {
     crypto::secret_key key;
     crypto::cn_slow_hash(passphrase.data(), passphrase.size(), (crypto::hash&)key);
     sc_reduce32((unsigned char*)key.data);
     data = encrypt(data, key, true);
   }
  
   if (raw)
   {
     seed = epee::to_hex::wipeable_string({(const unsigned char*)data.data(), data.size()});
   }
   else
   {
     if (!crypto::ElectrumWords::bytes_to_words(data.data(), data.size(), seed, seed_language))
     {
       std::cout << "Failed to encode seed";
       return false;
     }
   }
  
   return true;
 }

Here is the call graph for this function:

◆ get_multisig_signer_public_key() [1/2]

crypto::public_key tools::wallet2::get_multisig_signer_public_key ( ) const

Definition at line 12678 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
   crypto::public_key signer;
   CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(get_account().get_keys().m_spend_secret_key, signer), "Failed to generate signer public key");
   return signer;
 }

Here is the call graph for this function:

◆ get_multisig_signer_public_key() [2/2]

crypto::public_key tools::wallet2::get_multisig_signer_public_key ( const crypto::secret_key & spend_skey ) const

Definition at line 12671 of file wallet2.cpp.

 {
   crypto::public_key pkey;
   crypto::secret_key_to_public_key(get_multisig_blinded_secret_key(spend_skey), pkey);
   return pkey;
 }

Here is the call graph for this function:

◆ get_multisig_signing_public_key() [1/2]

crypto::public_key tools::wallet2::get_multisig_signing_public_key ( const crypto::secret_key & skey ) const

Definition at line 12686 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
   crypto::public_key pkey;
   CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(msk, pkey), "Failed to derive public key");
   return pkey;
 }

Here is the call graph for this function:

◆ get_multisig_signing_public_key() [2/2]

crypto::public_key tools::wallet2::get_multisig_signing_public_key ( size_t idx ) const

Definition at line 12694 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
   CHECK_AND_ASSERT_THROW_MES(idx < get_account().get_multisig_keys().size(), "Multisig signing key index out of range");
   return get_multisig_signing_public_key(get_account().get_multisig_keys()[idx]);
 }

◆ get_multisig_wallet_state()

mms::multisig_wallet_state tools::wallet2::get_multisig_wallet_state ( ) const

Definition at line 13395 of file wallet2.cpp.

 {
   mms::multisig_wallet_state state;
   state.nettype = m_nettype;
   state.multisig = multisig(&state.multisig_is_ready);
   state.has_multisig_partial_key_images = has_multisig_partial_key_images();
   state.multisig_rounds_passed = m_multisig_rounds_passed;
   state.num_transfer_details = m_transfers.size();
   if (state.multisig)
   {
     THROW_WALLET_EXCEPTION_IF(!m_original_keys_available, error::wallet_internal_error, "MMS use not possible because own original Electroneum address not available");
     state.address = m_original_address;
     state.view_secret_key = m_original_view_secret_key;
   }
   else
   {
     state.address = m_account.get_keys().m_account_address;
     state.view_secret_key = m_account.get_keys().m_view_secret_key;
   }
   state.mms_file=m_mms_file;
   return state;
 }

◆ get_num_rct_outputs()

uint64_t tools::wallet2::get_num_rct_outputs ( )

Definition at line 10621 of file wallet2.cpp.

 {
   cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t = AUTO_VAL_INIT(req_t);
   cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t = AUTO_VAL_INIT(resp_t);
   m_daemon_rpc_mutex.lock();
   req_t.amounts.push_back(0);
   req_t.min_count = 0;
   req_t.max_count = 0;
   req_t.unlocked = true;
   req_t.recent_cutoff = 0;
   bool r = invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_num_rct_outputs");
   THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
   THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
   THROW_WALLET_EXCEPTION_IF(resp_t.histogram.size() != 1, error::get_histogram_error, "Expected exactly one response");
   THROW_WALLET_EXCEPTION_IF(resp_t.histogram[0].amount != 0, error::get_histogram_error, "Expected 0 amount");
  
   return resp_t.histogram[0].total_instances;
 }

Here is the call graph for this function:

◆ get_num_subaddress_accounts()

size_t tools::wallet2::get_num_subaddress_accounts ( ) const

inline

Definition at line 795 of file wallet2.h.

795 { return m_subaddress_labels.size(); } // number of accounts in wallet

Here is the caller graph for this function:

◆ get_num_subaddresses()

size_t tools::wallet2::get_num_subaddresses ( uint32_t index_major ) const

inline

Definition at line 796 of file wallet2.h.

796 { return index_major < m_subaddress_labels.size() ? m_subaddress_labels[index_major].size() : 0; } // number of subaddresses in a particular account

Here is the caller graph for this function:

◆ get_num_transfer_details()

size_t tools::wallet2::get_num_transfer_details ( ) const

inline

Definition at line 1147 of file wallet2.h.

1147 { return m_transfers.size(); }

Here is the caller graph for this function:

◆ get_payments() [1/2]

void tools::wallet2::get_payments	(	const crypto::hash &	payment_id,
		std::list< wallet2::payment_details > &	payments,
		uint64_t	min_height = `0`,
		const boost::optional< uint32_t > &	subaddr_account = `boost::none`,
		const std::set< uint32_t > &	subaddr_indices = `{}`
	)		const

Definition at line 6210 of file wallet2.cpp.

 {
   auto range = m_payments.equal_range(payment_id);
   std::for_each(range.first, range.second, [&payments, &min_height, &subaddr_account, &subaddr_indices](const payment_container::value_type& x) {
     if (min_height < x.second.m_block_height &&
       (!subaddr_account || *subaddr_account == x.second.m_subaddr_index.major) &&
       (subaddr_indices.empty() || subaddr_indices.count(x.second.m_subaddr_index.minor) == 1))
     {
       payments.push_back(x.second);
     }
   });
 }

◆ get_payments() [2/2]

void tools::wallet2::get_payments	(	std::list< std::pair< crypto::hash, wallet2::payment_details >> &	payments,
		uint64_t	min_height,
		uint64_t	max_height = `(uint64_t)-1`,
		const boost::optional< uint32_t > &	subaddr_account = `boost::none`,
		const std::set< uint32_t > &	subaddr_indices = `{}`
	)		const

Definition at line 6223 of file wallet2.cpp.

 {
   auto range = std::make_pair(m_payments.begin(), m_payments.end());
   std::for_each(range.first, range.second, [&payments, &min_height, &max_height, &subaddr_account, &subaddr_indices](const payment_container::value_type& x) {
     if (min_height < x.second.m_block_height && max_height >= x.second.m_block_height &&
       (!subaddr_account || *subaddr_account == x.second.m_subaddr_index.major) &&
       (subaddr_indices.empty() || subaddr_indices.count(x.second.m_subaddr_index.minor) == 1))
     {
       payments.push_back(x);
     }
   });
 }

◆ get_payments_out()

void tools::wallet2::get_payments_out	(	std::list< std::pair< crypto::hash, wallet2::confirmed_transfer_details >> &	confirmed_payments,
		uint64_t	min_height,
		uint64_t	max_height = `(uint64_t)-1`,
		const boost::optional< uint32_t > &	subaddr_account = `boost::none`,
		const std::set< uint32_t > &	subaddr_indices = `{}`
	)		const

Definition at line 6236 of file wallet2.cpp.

 {
   for (auto i = m_confirmed_txs.begin(); i != m_confirmed_txs.end(); ++i) {
     if (i->second.m_block_height <= min_height || i->second.m_block_height > max_height)
       continue;
     if (subaddr_account && *subaddr_account != i->second.m_subaddr_account)
       continue;
     if (!subaddr_indices.empty() && std::count_if(i->second.m_subaddr_indices.begin(), i->second.m_subaddr_indices.end(), [&subaddr_indices](uint32_t index) { return subaddr_indices.count(index) == 1; }) == 0)
       continue;
     if (i->second.m_is_migration)
       continue;
     confirmed_payments.push_back(*i);
   }
 }//----------------------------------------------------------------------------------------------------

◆ get_payments_out_migration()

void tools::wallet2::get_payments_out_migration	(	std::list< std::pair< crypto::hash, wallet2::confirmed_transfer_details >> &	confirmed_payments,
		uint64_t	min_height,
		uint64_t	max_height = `(uint64_t)-1`,
		const boost::optional< uint32_t > &	subaddr_account = `boost::none`,
		const std::set< uint32_t > &	subaddr_indices = `{}`
	)		const

Definition at line 6251 of file wallet2.cpp.

 {
   for (auto i = m_confirmed_txs.begin(); i != m_confirmed_txs.end(); ++i) {
     if (i->second.m_block_height <= min_height || i->second.m_block_height > max_height)
       continue;
     if (subaddr_account && *subaddr_account != i->second.m_subaddr_account)
       continue;
     if (!subaddr_indices.empty() && std::count_if(i->second.m_subaddr_indices.begin(), i->second.m_subaddr_indices.end(), [&subaddr_indices](uint32_t index) { return subaddr_indices.count(index) == 1; }) == 0)
       continue;
     if (!i->second.m_is_migration)
       continue;
     confirmed_payments.push_back(*i);
   }
 }

◆ get_refresh_from_block_height()

uint64_t tools::wallet2::get_refresh_from_block_height ( ) const

inline

Definition at line 737 of file wallet2.h.

737 {return m_refresh_from_block_height;}

◆ get_refresh_type()

RefreshType tools::wallet2::get_refresh_type ( ) const

inline

Definition at line 816 of file wallet2.h.

816 { return m_refresh_type; }

◆ get_reserve_proof()

std::string tools::wallet2::get_reserve_proof	(	const boost::optional< std::pair< uint32_t, uint64_t >> &	account_minreserve,
		const std::string &	message
	)

Generates a proof that proves the reserve of unspent funds.

Parameters

account_minreserve	When specified, collect outputs only belonging to the given account and prove the smallest reserve above the given amount When unspecified, proves for all unspent outputs across all accounts
message	Arbitrary challenge message to be signed together

Returns: Signature string

Definition at line 11459 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(m_watch_only || m_multisig, error::wallet_internal_error, "Reserve proof can only be generated by a full wallet");
   THROW_WALLET_EXCEPTION_IF(balance_all(false) == 0, error::wallet_internal_error, "Zero balance");
   THROW_WALLET_EXCEPTION_IF(account_minreserve && balance(account_minreserve->first, false) < account_minreserve->second, error::wallet_internal_error,
     "Not enough balance in this account for the requested minimum reserve amount");
  
   // determine which outputs to include in the proof
   std::vector<size_t> selected_transfers;
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     const transfer_details &td = m_transfers[i];
     if (!td.m_spent && !td.m_frozen && (!account_minreserve || account_minreserve->first == td.m_subaddr_index.major))
       selected_transfers.push_back(i);
   }
  
   if (account_minreserve)
   {
     THROW_WALLET_EXCEPTION_IF(account_minreserve->second == 0, error::wallet_internal_error, "Proved amount must be greater than 0");
     // minimize the number of outputs included in the proof, by only picking the N largest outputs that can cover the requested min reserve amount
     std::sort(selected_transfers.begin(), selected_transfers.end(), [&](const size_t a, const size_t b)
       { return m_transfers[a].amount() > m_transfers[b].amount(); });
     while (selected_transfers.size() >= 2 && m_transfers[selected_transfers[1]].amount() >= account_minreserve->second)
       selected_transfers.erase(selected_transfers.begin());
     size_t sz = 0;
     uint64_t total = 0;
     while (total < account_minreserve->second)
     {
       total += m_transfers[selected_transfers[sz]].amount();
       ++sz;
     }
     selected_transfers.resize(sz);
   }
  
   // compute signature prefix hash
   std::string prefix_data = message;
   prefix_data.append((const char*)&m_account.get_keys().m_account_address, sizeof(cryptonote::account_public_address));
   for (size_t i = 0; i < selected_transfers.size(); ++i)
   {
     prefix_data.append((const char*)&m_transfers[selected_transfers[i]].m_key_image, sizeof(crypto::key_image));
   }
   crypto::hash prefix_hash;
   crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
  
   // generate proof entries
   std::vector<reserve_proof_entry> proofs(selected_transfers.size());
   std::unordered_set<cryptonote::subaddress_index> subaddr_indices = { {0,0} };
   for (size_t i = 0; i < selected_transfers.size(); ++i)
   {
     transfer_details &td = m_transfers[selected_transfers[i]];
     reserve_proof_entry& proof = proofs[i];
     proof.txid = td.m_txid;
     proof.index_in_tx = td.m_internal_output_index;
     proof.key_image = td.m_key_image;
     cryptonote::subaddress_index index2 = {td.m_subaddr_index.major + (td.m_subaddr_index.major != 0 ? m_account_major_offset : 0), td.m_subaddr_index.minor};
     td.m_subaddr_index = index2;
     subaddr_indices.insert(td.m_subaddr_index);
  
     // get tx pub key 
     const crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(td.m_tx, td.m_pk_index);
     THROW_WALLET_EXCEPTION_IF(tx_pub_key == crypto::null_pkey, error::wallet_internal_error, "The tx public key isn't found");
     const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
  
     // determine which tx pub key was used for deriving the output key
     const crypto::public_key *tx_pub_key_used = &tx_pub_key;
     for (int i = 0; i < 2; ++i)
     {
       proof.shared_secret = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(*tx_pub_key_used), rct::sk2rct(m_account.get_keys().m_view_secret_key)));
       crypto::key_derivation derivation;
       THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(proof.shared_secret, rct::rct2sk(rct::I), derivation),
         error::wallet_internal_error, "Failed to generate key derivation");
       crypto::public_key subaddress_spendkey;
       THROW_WALLET_EXCEPTION_IF(!derive_subaddress_public_key(td.get_public_key(), derivation, proof.index_in_tx, subaddress_spendkey),
         error::wallet_internal_error, "Failed to derive subaddress public key");
       if (m_subaddresses.count(subaddress_spendkey) == 1)
         break;
       THROW_WALLET_EXCEPTION_IF(additional_tx_pub_keys.empty(), error::wallet_internal_error,
         "Normal tx pub key doesn't derive the expected output, while the additional tx pub keys are empty");
       THROW_WALLET_EXCEPTION_IF(i == 1, error::wallet_internal_error,
         "Neither normal tx pub key nor additional tx pub key derive the expected output key");
       tx_pub_key_used = &additional_tx_pub_keys[proof.index_in_tx];
     }
  
     // generate signature for shared secret
     crypto::generate_tx_proof(prefix_hash, m_account.get_keys().m_account_address.m_view_public_key, *tx_pub_key_used, boost::none, proof.shared_secret, m_account.get_keys().m_view_secret_key, proof.shared_secret_sig);
  
     // derive ephemeral secret key
     crypto::key_image ki;
     cryptonote::keypair ephemeral;
     const bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, td.get_public_key(), tx_pub_key,  additional_tx_pub_keys, td.m_internal_output_index, ephemeral, ki, m_account.get_device(), m_account_major_offset);
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
     THROW_WALLET_EXCEPTION_IF(ephemeral.pub != td.get_public_key(), error::wallet_internal_error, "Derived public key doesn't agree with the stored one");
  
     // generate signature for key image
     const std::vector<const crypto::public_key*> pubs = { &ephemeral.pub };
     crypto::generate_ring_signature(prefix_hash, td.m_key_image, &pubs[0], 1, ephemeral.sec, 0, &proof.key_image_sig);
   }
  
   // collect all subaddress spend keys that received those outputs and generate their signatures
   std::unordered_map<crypto::public_key, crypto::signature> subaddr_spendkeys;
   for (const cryptonote::subaddress_index &index : subaddr_indices)
   {
     crypto::secret_key subaddr_spend_skey = m_account.get_keys().m_spend_secret_key;
     if (!index.is_zero())
     {
       crypto::secret_key m = m_account.get_device().get_subaddress_secret_key(m_account.get_keys().m_view_secret_key, index);
       crypto::secret_key tmp = subaddr_spend_skey;
       sc_add((unsigned char*)&subaddr_spend_skey, (unsigned char*)&m, (unsigned char*)&tmp);
     }
     crypto::public_key subaddr_spend_pkey;
     secret_key_to_public_key(subaddr_spend_skey, subaddr_spend_pkey);
     crypto::generate_signature(prefix_hash, subaddr_spend_pkey, subaddr_spend_skey, subaddr_spendkeys[subaddr_spend_pkey]);
   }
  
   // serialize & encode
   std::ostringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   ar << proofs << subaddr_spendkeys;
   return "ReserveProofV1" + tools::base58::encode(oss.str());
 }

Here is the call graph for this function:

◆ get_ring()

bool tools::wallet2::get_ring	(	const crypto::key_image &	key_image,
		std::vector< uint64_t > &	outs
	)

Definition at line 7847 of file wallet2.cpp.

 {
   try { return get_ring(get_ringdb_key(), key_image, outs); }
   catch (const std::exception &e) { return false; }
 }

◆ get_ring_database()

const std::string tools::wallet2::get_ring_database ( ) const

inline

Definition at line 1333 of file wallet2.h.

1333 { return m_ring_database; }

◆ get_rings()

bool tools::wallet2::get_rings	(	const crypto::hash &	txid,
		std::vector< std::pair< crypto::key_image, std::vector< uint64_t >>> &	outs
	)

Definition at line 7824 of file wallet2.cpp.

 {
   for (auto i: m_confirmed_txs)
   {
     if (txid == i.first)
     {
       for (const auto &x: i.second.m_rings)
         outs.push_back({x.first, cryptonote::relative_output_offsets_to_absolute(x.second)});
       return true;
     }
   }
   for (auto i: m_unconfirmed_txs)
   {
     if (txid == i.first)
     {
       for (const auto &x: i.second.m_rings)
         outs.push_back({x.first, cryptonote::relative_output_offsets_to_absolute(x.second)});
       return true;
     }
   }
   return false;
 }

Here is the call graph for this function:

◆ get_seed()

bool tools::wallet2::get_seed	(	epee::wipeable_string &	electrum_words,
		const epee::wipeable_string &	passphrase = `epee::wipeable_string()`
	)		const

Definition at line 1300 of file wallet2.cpp.

 {
   bool keys_deterministic = is_deterministic();
   if (!keys_deterministic)
   {
     std::cout << "This is not a deterministic wallet" << std::endl;
     return false;
   }
   if (seed_language.empty())
   {
     std::cout << "seed_language not set" << std::endl;
     return false;
   }
  
   crypto::secret_key key = get_account().get_keys().m_spend_secret_key;
   if (!passphrase.empty())
     key = cryptonote::encrypt_key(key, passphrase);
   if (!crypto::ElectrumWords::bytes_to_words(key, electrum_words, seed_language))
   {
     std::cout << "Failed to create seed from key for language: " << seed_language << std::endl;
     return false;
   }
  
   return true;
 }

Here is the call graph for this function:

◆ get_seed_language()

const std::string & tools::wallet2::get_seed_language ( ) const

Gets the seed language.

Definition at line 1416 of file wallet2.cpp.

 {
   return seed_language;
 }

◆ get_spend_proof()

std::string tools::wallet2::get_spend_proof	(	const crypto::hash &	txid,
		const std::string &	message
	)

Definition at line 10837 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(m_watch_only, error::wallet_internal_error,
     "get_spend_proof requires spend secret key and is not available for a watch-only wallet");
  
   // fetch tx from daemon
   COMMAND_RPC_GET_TRANSACTIONS::request req = AUTO_VAL_INIT(req);
   req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
   req.decode_as_json = false;
   req.prune = true;
   COMMAND_RPC_GET_TRANSACTIONS::response res = AUTO_VAL_INIT(res);
   bool r;
   {
     const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
     r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
   }
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.txs.size() != 1, error::wallet_internal_error,
     "daemon returned wrong response for gettransactions, wrong txs count = " +
     std::to_string(res.txs.size()) + ", expected 1");
  
   cryptonote::transaction tx;
   crypto::hash tx_hash;
   THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(res.txs[0], tx, tx_hash), error::wallet_internal_error, "Failed to get tx from daemon");
  
   std::vector<std::vector<crypto::signature>> signatures;
  
   // get signature prefix hash
   std::string sig_prefix_data((const char*)&txid, sizeof(crypto::hash));
   sig_prefix_data += message;
   crypto::hash sig_prefix_hash;
   crypto::cn_fast_hash(sig_prefix_data.data(), sig_prefix_data.size(), sig_prefix_hash);
  
   for(size_t i = 0; i < tx.vin.size(); ++i)
   {
     const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
     if (in_key == nullptr)
       continue;
  
     // check if the key image belongs to us
     const auto found = m_key_images.find(in_key->k_image);
     if(found == m_key_images.end())
     {
       THROW_WALLET_EXCEPTION_IF(i > 0, error::wallet_internal_error, "subset of key images belong to us, very weird!");
       THROW_WALLET_EXCEPTION_IF(true, error::wallet_internal_error, "This tx wasn't generated by this wallet!");
     }
  
     // derive the real output keypair
     const transfer_details& in_td = m_transfers[found->second];
     const txout_to_key* const in_tx_out_pkey = boost::get<txout_to_key>(std::addressof(in_td.m_tx.vout[in_td.m_internal_output_index].target));
     THROW_WALLET_EXCEPTION_IF(in_tx_out_pkey == nullptr, error::wallet_internal_error, "Output is not txout_to_key");
     const crypto::public_key in_tx_pub_key = get_tx_pub_key_from_extra(in_td.m_tx, in_td.m_pk_index);
     const std::vector<crypto::public_key> in_additionakl_tx_pub_keys = get_additional_tx_pub_keys_from_extra(in_td.m_tx);
     keypair in_ephemeral;
     crypto::key_image in_img;
     THROW_WALLET_EXCEPTION_IF(!generate_key_image_helper(m_account.get_keys(), m_subaddresses, in_tx_out_pkey->key, in_tx_pub_key, in_additionakl_tx_pub_keys, in_td.m_internal_output_index, in_ephemeral, in_img, m_account.get_device(), m_account_major_offset),
       error::wallet_internal_error, "failed to generate key image");
     THROW_WALLET_EXCEPTION_IF(in_key->k_image != in_img, error::wallet_internal_error, "key image mismatch");
  
     // get output pubkeys in the ring
     const std::vector<uint64_t> absolute_offsets = cryptonote::relative_output_offsets_to_absolute(in_key->key_offsets);
     const size_t ring_size = in_key->key_offsets.size();
     THROW_WALLET_EXCEPTION_IF(absolute_offsets.size() != ring_size, error::wallet_internal_error, "absolute offsets size is wrong");
     COMMAND_RPC_GET_OUTPUTS_BIN::request req = AUTO_VAL_INIT(req);
     req.outputs.resize(ring_size);
     for (size_t j = 0; j < ring_size; ++j)
     {
       req.outputs[j].amount = in_key->amount;
       req.outputs[j].index = absolute_offsets[j];
     }
     COMMAND_RPC_GET_OUTPUTS_BIN::response res = AUTO_VAL_INIT(res);
     bool r;
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex}; 
       r = invoke_http_bin("/get_outs.bin", req, res, rpc_timeout);
     }
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(res.outs.size() != ring_size, error::wallet_internal_error,
       "daemon returned wrong response for get_outs.bin, wrong amounts count = " +
       std::to_string(res.outs.size()) + ", expected " +  std::to_string(ring_size));
  
     // copy pubkey pointers
     std::vector<const crypto::public_key *> p_output_keys;
     for (const COMMAND_RPC_GET_OUTPUTS_BIN::outkey &out : res.outs)
       p_output_keys.push_back(&out.key);
  
     // figure out real output index and secret key
     size_t sec_index = -1;
     for (size_t j = 0; j < ring_size; ++j)
     {
       if (res.outs[j].key == in_ephemeral.pub)
       {
         sec_index = j;
         break;
       }
     }
     THROW_WALLET_EXCEPTION_IF(sec_index >= ring_size, error::wallet_internal_error, "secret index not found");
  
     // generate ring sig for this input
     signatures.push_back(std::vector<crypto::signature>());
     std::vector<crypto::signature>& sigs = signatures.back();
     sigs.resize(in_key->key_offsets.size());
     crypto::generate_ring_signature(sig_prefix_hash, in_key->k_image, p_output_keys, in_ephemeral.sec, sec_index, sigs.data());
   }
  
   std::string sig_str = "SpendProofV1";
   for (const std::vector<crypto::signature>& ring_sig : signatures)
     for (const crypto::signature& sig : ring_sig)
        sig_str += tools::base58::encode(std::string((const char *)&sig, sizeof(crypto::signature)));
   return sig_str;
 }

Here is the call graph for this function:

◆ get_subaddress()

cryptonote::account_public_address tools::wallet2::get_subaddress ( const cryptonote::subaddress_index & index ) const

Definition at line 1429 of file wallet2.cpp.

 {
   hw::device &hwdev = m_account.get_device();
   cryptonote::subaddress_index index2 = {index.major + (index.major != 0 ? m_account_major_offset : 0), index.minor};
   return hwdev.get_subaddress(m_account.get_keys(), index2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_subaddress_as_str()

std::string tools::wallet2::get_subaddress_as_str ( const cryptonote::subaddress_index & index ) const

Definition at line 1451 of file wallet2.cpp.

 {
   cryptonote::account_public_address address = get_subaddress(index);
   return cryptonote::get_account_address_as_str(m_nettype, !index.is_zero(), address);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_subaddress_index()

boost::optional< cryptonote::subaddress_index > tools::wallet2::get_subaddress_index ( const cryptonote::account_public_address & address ) const

Definition at line 1436 of file wallet2.cpp.

 {
   auto index = m_subaddresses.find(address.m_spend_public_key);
   if (index == m_subaddresses.end())
     return boost::none;
   return index->second;
 }

◆ get_subaddress_label()

std::string tools::wallet2::get_subaddress_label ( const cryptonote::subaddress_index & index ) const

Definition at line 1517 of file wallet2.cpp.

 {
   if (index.major >= m_subaddress_labels.size() || index.minor >= m_subaddress_labels[index.major].size())
   {
     MERROR("Subaddress label doesn't exist");
     return "";
   }
   return m_subaddress_labels[index.major][index.minor];
 }

◆ get_subaddress_lookahead()

std::pair<size_t, size_t> tools::wallet2::get_subaddress_lookahead ( ) const

inline

Definition at line 802 of file wallet2.h.

802 { return {m_subaddress_lookahead_major, m_subaddress_lookahead_minor}; }

◆ get_subaddress_spend_public_key()

crypto::public_key tools::wallet2::get_subaddress_spend_public_key ( const cryptonote::subaddress_index & index ) const

Definition at line 1444 of file wallet2.cpp.

 {
   hw::device &hwdev = m_account.get_device();
   cryptonote::subaddress_index index2 = {index.major + (index.major != 0 ? m_account_major_offset : 0), index.minor};
   return hwdev.get_subaddress_spend_public_key(m_account.get_keys(), index2);
 }

Here is the call graph for this function:

◆ get_subaddress_spend_public_keys()

std::vector<crypto::public_key> tools::wallet2::get_subaddress_spend_public_keys	(	uint32_t	account,
		uint32_t	begin,
		uint32_t	end
	)		const

◆ get_transfer_details()

const wallet2::transfer_details & tools::wallet2::get_transfer_details ( size_t idx ) const

Definition at line 10642 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error, "Bad transfer index");
   return m_transfers[idx];
 }

Here is the caller graph for this function:

◆ get_transfers()

void tools::wallet2::get_transfers ( wallet2::transfer_container & incoming_transfers ) const

Definition at line 6205 of file wallet2.cpp.

 {
   incoming_transfers = m_transfers;
 }

Here is the caller graph for this function:

◆ get_tx_device_aux()

std::string tools::wallet2::get_tx_device_aux ( const crypto::hash & txid ) const

Definition at line 11795 of file wallet2.cpp.

 {
   std::unordered_map<crypto::hash, std::string>::const_iterator i = m_tx_device.find(txid);
   if (i == m_tx_device.end())
     return std::string();
   return i->second;
 }

◆ get_tx_key()

bool tools::wallet2::get_tx_key	(	const crypto::hash &	txid,
		crypto::secret_key &	tx_key,
		std::vector< crypto::secret_key > &	additional_tx_keys
	)

Definition at line 10714 of file wallet2.cpp.

 {
   bool r = get_tx_key_cached(txid, tx_key, additional_tx_keys);
   if (r)
   {
     return true;
   }
  
   auto & hwdev = get_account().get_device();
  
   // So far only Cold protocol devices are supported.
   if (hwdev.device_protocol() != hw::device::PROTOCOL_COLD)
   {
     return false;
   }
  
   const auto tx_data_it = m_tx_device.find(txid);
   if (tx_data_it == m_tx_device.end())
   {
     MDEBUG("Aux data not found for txid: " << txid);
     return false;
   }
  
   auto dev_cold = dynamic_cast<::hw::device_cold*>(&hwdev);
   CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
   if (!dev_cold->is_get_tx_key_supported())
   {
     MDEBUG("get_tx_key not supported by the device");
     return false;
   }
  
   hw::device_cold::tx_key_data_t tx_key_data;
   dev_cold->load_tx_key_data(tx_key_data, tx_data_it->second);
  
   // Load missing tx prefix hash
   if (tx_key_data.tx_prefix_hash.empty())
   {
     COMMAND_RPC_GET_TRANSACTIONS::request req;
     COMMAND_RPC_GET_TRANSACTIONS::response res;
     req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
     req.decode_as_json = false;
     req.prune = true;
     m_daemon_rpc_mutex.lock();
     bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
                               error::wallet_internal_error, "Failed to get transaction from daemon");
  
     cryptonote::transaction tx;
     crypto::hash tx_hash{};
     cryptonote::blobdata tx_data;
     crypto::hash tx_prefix_hash{};
     ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
     THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
     THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx, tx_hash, tx_prefix_hash),
                               error::wallet_internal_error, "Failed to validate transaction from daemon");
     THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error,
                               "Failed to get the right transaction from daemon");
  
     tx_key_data.tx_prefix_hash = std::string(tx_prefix_hash.data, 32);
   }
  
   std::vector<crypto::secret_key> tx_keys;
   dev_cold->get_tx_key(tx_keys, tx_key_data, m_account.get_keys().m_view_secret_key);
   if (tx_keys.empty())
   {
     return false;
   }
  
   tx_key = tx_keys[0];
   tx_keys.erase(tx_keys.begin());
   additional_tx_keys = tx_keys;
  
   return true;
 }

Here is the call graph for this function:

◆ get_tx_key_cached()

bool tools::wallet2::get_tx_key_cached	(	const crypto::hash &	txid,
		crypto::secret_key &	tx_key,
		std::vector< crypto::secret_key > &	additional_tx_keys
	)		const

Definition at line 10701 of file wallet2.cpp.

 {
   additional_tx_keys.clear();
   const std::unordered_map<crypto::hash, crypto::secret_key>::const_iterator i = m_tx_keys.find(txid);
   if (i == m_tx_keys.end())
     return false;
   tx_key = i->second;
   const auto j = m_additional_tx_keys.find(txid);
   if (j != m_additional_tx_keys.end())
     additional_tx_keys = j->second;
   return true;
 }

◆ get_tx_note()

std::string tools::wallet2::get_tx_note ( const crypto::hash & txid ) const

Definition at line 11782 of file wallet2.cpp.

 {
   std::unordered_map<crypto::hash, std::string>::const_iterator i = m_tx_notes.find(txid);
   if (i == m_tx_notes.end())
     return std::string();
   return i->second;
 }

◆ get_tx_proof() [1/2]

std::string tools::wallet2::get_tx_proof	(	const crypto::hash &	txid,
		const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const std::string &	message
	)

Definition at line 11161 of file wallet2.cpp.

 {
     // fetch tx pubkey from the daemon
     COMMAND_RPC_GET_TRANSACTIONS::request req;
     COMMAND_RPC_GET_TRANSACTIONS::response res;
     req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
     req.decode_as_json = false;
     req.prune = true;
     m_daemon_rpc_mutex.lock();
     bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
       error::wallet_internal_error, "Failed to get transaction from daemon");
  
     cryptonote::transaction tx;
     crypto::hash tx_hash;
     if (res.txs.size() == 1)
     {
       ok = get_pruned_tx(res.txs.front(), tx, tx_hash);
       THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
     }
     else
     {
       cryptonote::blobdata tx_data;
       ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
       THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
       THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx),
           error::wallet_internal_error, "Failed to validate transaction from daemon");
       tx_hash = cryptonote::get_transaction_hash(tx);
     }
  
     CHECK_AND_ASSERT_THROW_MES(tx.version == 1, "Tx proofs are for v1 transactions only");
     THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
  
     // determine if the address is found in the subaddress hash table (i.e. whether the proof is outbound or inbound)
     crypto::secret_key tx_key = crypto::null_skey;
     std::vector<crypto::secret_key> additional_tx_keys;
     const bool is_out = m_subaddresses.count(address.m_spend_public_key) == 0;
     if (is_out)
     {
       THROW_WALLET_EXCEPTION_IF(!get_tx_key(txid, tx_key, additional_tx_keys), error::wallet_internal_error, "Tx secret key wasn't found in the wallet file.");
     }
  
     return get_tx_proof(tx, tx_key, additional_tx_keys, address, is_subaddress, message);
 }

Here is the call graph for this function:

◆ get_tx_proof() [2/2]

std::string tools::wallet2::get_tx_proof	(	const cryptonote::transaction &	tx,
		const crypto::secret_key &	tx_key,
		const std::vector< crypto::secret_key > &	additional_tx_keys,
		const cryptonote::account_public_address &	address,
		bool	is_subaddress,
		const std::string &	message
	)		const

Definition at line 11207 of file wallet2.cpp.

 {
   hw::device &hwdev = m_account.get_device();
   rct::key  aP;
   // determine if the address is found in the subaddress hash table (i.e. whether the proof is outbound or inbound)
   const bool is_out = m_subaddresses.count(address.m_spend_public_key) == 0;
  
   const crypto::hash txid = cryptonote::get_transaction_hash(tx);
   std::string prefix_data((const char*)&txid, sizeof(crypto::hash));
   prefix_data += message;
   crypto::hash prefix_hash;
   crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
  
   std::vector<crypto::public_key> shared_secret;
   std::vector<crypto::signature> sig;
   std::string sig_str;
   if (is_out)
   {
     const size_t num_sigs = 1 + additional_tx_keys.size();
     shared_secret.resize(num_sigs);
     sig.resize(num_sigs);
  
     hwdev.scalarmultKey(aP, rct::pk2rct(address.m_view_public_key), rct::sk2rct(tx_key));
     shared_secret[0] = rct::rct2pk(aP);
     crypto::public_key tx_pub_key;
     if (is_subaddress)
     {
       hwdev.scalarmultKey(aP, rct::pk2rct(address.m_spend_public_key), rct::sk2rct(tx_key));
       tx_pub_key = rct2pk(aP);
       hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, address.m_spend_public_key, shared_secret[0], tx_key, sig[0]);
     }
     else
     {
       hwdev.secret_key_to_public_key(tx_key, tx_pub_key);
       hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, boost::none, shared_secret[0], tx_key, sig[0]);
     }
     for (size_t i = 1; i < num_sigs; ++i)
     {
       hwdev.scalarmultKey(aP, rct::pk2rct(address.m_view_public_key), rct::sk2rct(additional_tx_keys[i - 1]));
       shared_secret[i] = rct::rct2pk(aP);
       if (is_subaddress)
       {
         hwdev.scalarmultKey(aP, rct::pk2rct(address.m_spend_public_key), rct::sk2rct(additional_tx_keys[i - 1]));
         tx_pub_key = rct2pk(aP);
         hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, address.m_spend_public_key, shared_secret[i], additional_tx_keys[i - 1], sig[i]);
       }
       else
       {
         hwdev.secret_key_to_public_key(additional_tx_keys[i - 1], tx_pub_key);
         hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, boost::none, shared_secret[i], additional_tx_keys[i - 1], sig[i]);
       }
     }
     sig_str = std::string("OutProofV1");
   }
   else
   {
     crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
     THROW_WALLET_EXCEPTION_IF(tx_pub_key == null_pkey, error::wallet_internal_error, "Tx pubkey was not found");
  
     std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
     const size_t num_sigs = 1 + additional_tx_pub_keys.size();
     shared_secret.resize(num_sigs);
     sig.resize(num_sigs);
  
     const crypto::secret_key& a = m_account.get_keys().m_view_secret_key;
     hwdev.scalarmultKey(aP, rct::pk2rct(tx_pub_key), rct::sk2rct(a));
     shared_secret[0] =  rct2pk(aP);
     if (is_subaddress)
     {
       hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, address.m_spend_public_key, shared_secret[0], a, sig[0]);
     }
     else
     {
       hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, shared_secret[0], a, sig[0]);
     }
     for (size_t i = 1; i < num_sigs; ++i)
     {
       hwdev.scalarmultKey(aP,rct::pk2rct(additional_tx_pub_keys[i - 1]), rct::sk2rct(a));
       shared_secret[i] = rct2pk(aP);
       if (is_subaddress)
       {
         hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i - 1], address.m_spend_public_key, shared_secret[i], a, sig[i]);
       }
       else
       {
         hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i - 1], boost::none, shared_secret[i], a, sig[i]);
       }
     }
     sig_str = std::string("InProofV1");
   }
   const size_t num_sigs = shared_secret.size();
  
   // check if this address actually received any funds
   crypto::key_derivation derivation;
   THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[0], rct::rct2sk(rct::I), derivation), error::wallet_internal_error, "Failed to generate key derivation");
   std::vector<crypto::key_derivation> additional_derivations(num_sigs - 1);
   for (size_t i = 1; i < num_sigs; ++i)
     THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[i], rct::rct2sk(rct::I), additional_derivations[i - 1]), error::wallet_internal_error, "Failed to generate key derivation");
   uint64_t received;
   check_tx_key_helper(tx, derivation, additional_derivations, address, received);
   THROW_WALLET_EXCEPTION_IF(!received, error::wallet_internal_error, tr("No funds received in this tx."));
  
   // concatenate all signature strings
   for (size_t i = 0; i < num_sigs; ++i)
     sig_str +=
       tools::base58::encode(std::string((const char *)&shared_secret[i], sizeof(crypto::public_key))) +
       tools::base58::encode(std::string((const char *)&sig[i], sizeof(crypto::signature)));
   return sig_str;
 }

Here is the call graph for this function:

◆ get_tx_pub_key_from_received_outs()

crypto::public_key tools::wallet2::get_tx_pub_key_from_received_outs ( const tools::wallet2::transfer_details & td ) const

Definition at line 11933 of file wallet2.cpp.

 {
   std::vector<tx_extra_field> tx_extra_fields;
   if(!parse_tx_extra(td.m_tx.extra, tx_extra_fields))
   {
     // Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
   }
  
   // Due to a previous bug, there might be more than one tx pubkey in extra, one being
   // the result of a previously discarded signature.
   // For speed, since scanning for outputs is a slow process, we check whether extra
   // contains more than one pubkey. If not, the first one is returned. If yes, they're
   // checked for whether they yield at least one output
   tx_extra_pub_key pub_key_field;
   THROW_WALLET_EXCEPTION_IF(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, 0), error::wallet_internal_error,
       "Public key wasn't found in the transaction extra");
   const crypto::public_key tx_pub_key = pub_key_field.pub_key;
   bool two_found = find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, 1);
   if (!two_found) {
     // easy case, just one found
     return tx_pub_key;
   }
  
   // more than one, loop and search
   const cryptonote::account_keys& keys = m_account.get_keys();
   size_t pk_index = 0;
   hw::device &hwdev = m_account.get_device();
  
   while (find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, pk_index++)) {
     const crypto::public_key tx_pub_key = pub_key_field.pub_key;
     crypto::key_derivation derivation;
     bool r = hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation);
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
  
     for (size_t i = 0; i < td.m_tx.vout.size(); ++i)
     {
       tx_scan_info_t tx_scan_info;
       check_acc_out_precomp(td.m_tx.vout[i], derivation, {}, i, tx_scan_info);
       if (!tx_scan_info.error && tx_scan_info.received)
         return tx_pub_key;
     }
   }
  
   // we found no key yielding an output, but it might be in the additional
   // tx pub keys only, which we do not need to check, so return the first one
   return tx_pub_key;
 }

◆ get_unconfirmed_payments()

void tools::wallet2::get_unconfirmed_payments	(	std::list< std::pair< crypto::hash, wallet2::pool_payment_details >> &	unconfirmed_payments,
		const boost::optional< uint32_t > &	subaddr_account = `boost::none`,
		const std::set< uint32_t > &	subaddr_indices = `{}`
	)		const

Definition at line 6278 of file wallet2.cpp.

 {
   for (auto i = m_unconfirmed_payments.begin(); i != m_unconfirmed_payments.end(); ++i) {
     if ((!subaddr_account || *subaddr_account == i->second.m_pd.m_subaddr_index.major) &&
       (subaddr_indices.empty() || subaddr_indices.count(i->second.m_pd.m_subaddr_index.minor) == 1))
     unconfirmed_payments.push_back(*i);
   }
 }

◆ get_unconfirmed_payments_out()

void tools::wallet2::get_unconfirmed_payments_out	(	std::list< std::pair< crypto::hash, wallet2::unconfirmed_transfer_details >> &	unconfirmed_payments,
		const boost::optional< uint32_t > &	subaddr_account = `boost::none`,
		const std::set< uint32_t > &	subaddr_indices = `{}`
	)		const

Definition at line 6267 of file wallet2.cpp.

 {
   for (auto i = m_unconfirmed_txs.begin(); i != m_unconfirmed_txs.end(); ++i) {
     if (subaddr_account && *subaddr_account != i->second.m_subaddr_account)
       continue;
     if (!subaddr_indices.empty() && std::count_if(i->second.m_subaddr_indices.begin(), i->second.m_subaddr_indices.end(), [&subaddr_indices](uint32_t index) { return subaddr_indices.count(index) == 1; }) == 0)
       continue;
     unconfirmed_payments.push_back(*i);
   }
 }

◆ get_wallet_file()

std::string tools::wallet2::get_wallet_file ( ) const

Definition at line 11706 of file wallet2.cpp.

 {
   return m_wallet_file;
 }

◆ has_multisig_partial_key_images()

bool tools::wallet2::has_multisig_partial_key_images ( ) const

Definition at line 5537 of file wallet2.cpp.

 {
   if (!m_multisig)
     return false;
   for (const auto &td: m_transfers)
     if (td.m_key_image_partial && td.m_tx.version == 1)
       return true;
   return false;
 }

◆ has_stagenet_option()

bool tools::wallet2::has_stagenet_option ( const boost::program_options::variables_map & vm )

static

Definition at line 1177 of file wallet2.cpp.

 {
   return command_line::get_arg(vm, options().stagenet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_testnet_option()

bool tools::wallet2::has_testnet_option ( const boost::program_options::variables_map & vm )

static

Definition at line 1172 of file wallet2.cpp.

 {
   return command_line::get_arg(vm, options().testnet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_unknown_key_images()

bool tools::wallet2::has_unknown_key_images ( ) const

Definition at line 5547 of file wallet2.cpp.

 {
   for (const auto &td: m_transfers)
     if (!td.m_key_image_known && td.m_tx.version == 1)
       return true;
   return false;
 }

◆ hash_m_transfer()

void tools::wallet2::hash_m_transfer	(	const transfer_details &	transfer,
		crypto::hash &	hash
	)		const

Definition at line 13479 of file wallet2.cpp.

 {
   KECCAK_CTX state;
   keccak_init(&state);
   keccak_update(&state, (const uint8_t *) transfer.m_txid.data, sizeof(transfer.m_txid.data));
   keccak_update(&state, (const uint8_t *) transfer.m_internal_output_index, sizeof(transfer.m_internal_output_index));
   keccak_update(&state, (const uint8_t *) transfer.m_global_output_index, sizeof(transfer.m_global_output_index));
   keccak_update(&state, (const uint8_t *) transfer.m_amount, sizeof(transfer.m_amount));
   keccak_finish(&state, (uint8_t *) hash.data);
 }

Here is the call graph for this function:

◆ hash_m_transfers()

uint64_t tools::wallet2::hash_m_transfers	(	int64_t	transfer_height,
		crypto::hash &	hash
	)		const

Definition at line 13490 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(transfer_height > (int64_t)m_transfers.size(), "Hash height is greater than number of transfers");
  
   KECCAK_CTX state;
   crypto::hash tmp_hash{};
   uint64_t current_height = 0;
  
   keccak_init(&state);
   for(const transfer_details & transfer : m_transfers){
     if (transfer_height >= 0 && current_height >= (uint64_t)transfer_height){
       break;
     }
  
     hash_m_transfer(transfer, tmp_hash);
     keccak_update(&state, (const uint8_t *) transfer.m_block_height, sizeof(transfer.m_block_height));
     keccak_update(&state, (const uint8_t *) tmp_hash.data, sizeof(tmp_hash.data));
     current_height += 1;
   }
  
   keccak_finish(&state, (uint8_t *) hash.data);
   return current_height;
 }

Here is the call graph for this function:

◆ ignore_fractional_outputs() [1/2]

bool tools::wallet2::ignore_fractional_outputs ( ) const

inline

Definition at line 1093 of file wallet2.h.

1093 { return m_ignore_fractional_outputs; }

◆ ignore_fractional_outputs() [2/2]

void tools::wallet2::ignore_fractional_outputs ( bool value )

inline

Definition at line 1094 of file wallet2.h.

1094 { m_ignore_fractional_outputs = value; }

◆ import_blockchain()

void tools::wallet2::import_blockchain ( const std::tuple< size_t, crypto::hash, std::vector< crypto::hash >> & bc )

Definition at line 12483 of file wallet2.cpp.

 {
   m_blockchain.clear();
   if (std::get<0>(bc))
   {
     for (size_t n = std::get<0>(bc); n > 0; --n)
       m_blockchain.push_back(std::get<1>(bc));
     m_blockchain.trim(std::get<0>(bc));
   }
   for (auto const &b : std::get<2>(bc))
   {
     m_blockchain.push_back(b);
   }
   cryptonote::block genesis;
   generate_genesis(genesis);
   crypto::hash genesis_hash = get_block_hash(genesis);
   check_genesis(genesis_hash);
   m_last_block_reward = cryptonote::get_outs_etn_amount(genesis.miner_tx);
 }

◆ import_key_images() [1/4]

uint64_t tools::wallet2::import_key_images	(	const std::string &	filename,
		uint64_t &	spent,
		uint64_t &	unspent
	)

Definition at line 12068 of file wallet2.cpp.

 {
   PERF_TIMER(import_key_images_fsu);
   std::string data;
   bool r = epee::file_io_utils::load_file_to_string(filename, data);
  
   THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, std::string(tr("failed to read file ")) + filename);
  
   const size_t magiclen = strlen(KEY_IMAGE_EXPORT_FILE_MAGIC);
   if (data.size() < magiclen || memcmp(data.data(), KEY_IMAGE_EXPORT_FILE_MAGIC, magiclen))
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Bad key image export file magic in ") + filename);
   }
  
   try
   {
     PERF_TIMER(import_key_images_decrypt);
     data = decrypt_with_view_secret_key(std::string(data, magiclen));
   }
   catch (const std::exception &e)
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Failed to decrypt ") + filename + ": " + e.what());
   }
  
   const size_t headerlen = 4 + 2 * sizeof(crypto::public_key);
   THROW_WALLET_EXCEPTION_IF(data.size() < headerlen, error::wallet_internal_error, std::string("Bad data size from file ") + filename);
   const uint32_t offset = (uint8_t)data[0] | (((uint8_t)data[1]) << 8) | (((uint8_t)data[2]) << 16) | (((uint8_t)data[3]) << 24);
   const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[4];
   const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[4 + sizeof(crypto::public_key)];
   const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
   if (public_spend_key != keys.m_spend_public_key || public_view_key != keys.m_view_public_key)
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string( "Key images from ") + filename + " are for a different account");
   }
   THROW_WALLET_EXCEPTION_IF(offset > m_transfers.size(), error::wallet_internal_error, "Offset larger than known outputs");
  
   const size_t record_size = sizeof(crypto::key_image) + sizeof(crypto::signature);
   THROW_WALLET_EXCEPTION_IF((data.size() - headerlen) % record_size,
       error::wallet_internal_error, std::string("Bad data size from file ") + filename);
   size_t nki = (data.size() - headerlen) / record_size;
  
   std::vector<std::pair<crypto::key_image, crypto::signature>> ski;
   ski.reserve(nki);
   for (size_t n = 0; n < nki; ++n)
   {
     crypto::key_image key_image = *reinterpret_cast<const crypto::key_image*>(&data[headerlen + n * record_size]);
     crypto::signature signature = *reinterpret_cast<const crypto::signature*>(&data[headerlen + n * record_size + sizeof(crypto::key_image)]);
  
     ski.push_back(std::make_pair(key_image, signature));
   }
   
   return import_key_images(ski, offset, spent, unspent);
 }

Here is the call graph for this function:

◆ import_key_images() [2/4]

uint64_t tools::wallet2::import_key_images	(	const std::vector< std::pair< crypto::key_image, crypto::signature >> &	signed_key_images,
		size_t	offset,
		uint64_t &	spent,
		uint64_t &	unspent,
		bool	check_spent = `true`
	)

Definition at line 12123 of file wallet2.cpp.

 {
   PERF_TIMER(import_key_images_lots);
   COMMAND_RPC_IS_KEY_IMAGE_SPENT::request req = AUTO_VAL_INIT(req);
   COMMAND_RPC_IS_KEY_IMAGE_SPENT::response daemon_resp = AUTO_VAL_INIT(daemon_resp);
  
   THROW_WALLET_EXCEPTION_IF(offset > m_transfers.size(), error::wallet_internal_error, "Offset larger than known outputs");
   THROW_WALLET_EXCEPTION_IF(signed_key_images.size() > m_transfers.size() - offset, error::wallet_internal_error,
       "The blockchain is out of date compared to the signed key images");
  
   if (signed_key_images.empty() && offset == 0)
   {
     spent = 0;
     unspent = 0;
     return 0;
   }
  
   req.key_images.reserve(signed_key_images.size());
  
   PERF_TIMER_START(import_key_images_A);
   for (size_t n = 0; n < signed_key_images.size(); ++n)
   {
     const transfer_details &td = m_transfers[n + offset];
     const crypto::key_image &key_image = signed_key_images[n].first;
     const crypto::signature &signature = signed_key_images[n].second;
  
     // get ephemeral public key
     const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
     THROW_WALLET_EXCEPTION_IF(out.target.type() != typeid(txout_to_key), error::wallet_internal_error,
       "Non txout_to_key output found");
     const cryptonote::txout_to_key &o = boost::get<cryptonote::txout_to_key>(out.target);
     const crypto::public_key pkey = o.key;
  
     if (!td.m_key_image_known || !(key_image == td.m_key_image))
     {
       std::vector<const crypto::public_key*> pkeys;
       pkeys.push_back(&pkey);
       THROW_WALLET_EXCEPTION_IF(!(rct::scalarmultKey(rct::ki2rct(key_image), rct::curveOrder()) == rct::identity()),
           error::wallet_internal_error, "Key image out of validity domain: input " + boost::lexical_cast<std::string>(n + offset) + "/"
           + boost::lexical_cast<std::string>(signed_key_images.size()) + ", key image " + epee::string_tools::pod_to_hex(key_image));
  
       THROW_WALLET_EXCEPTION_IF(!crypto::check_ring_signature((const crypto::hash&)key_image, key_image, pkeys, &signature),
           error::signature_check_failed, boost::lexical_cast<std::string>(n + offset) + "/"
           + boost::lexical_cast<std::string>(signed_key_images.size()) + ", key image " + epee::string_tools::pod_to_hex(key_image)
           + ", signature " + epee::string_tools::pod_to_hex(signature) + ", pubkey " + epee::string_tools::pod_to_hex(*pkeys[0]));
     }
     req.key_images.push_back(epee::string_tools::pod_to_hex(key_image));
   }
   PERF_TIMER_STOP(import_key_images_A);
  
   PERF_TIMER_START(import_key_images_B);
   for (size_t n = 0; n < signed_key_images.size(); ++n)
   {
     m_transfers[n + offset].m_key_image = signed_key_images[n].first;
     m_key_images[m_transfers[n + offset].m_key_image] = n + offset;
     m_transfers[n + offset].m_key_image_known = true;
     m_transfers[n + offset].m_key_image_request = false;
     m_transfers[n + offset].m_key_image_partial = false;
   }
   PERF_TIMER_STOP(import_key_images_B);
  
   if(check_spent)
   {
     PERF_TIMER(import_key_images_RPC);
     m_daemon_rpc_mutex.lock();
     bool r = invoke_http_json("/is_key_image_spent", req, daemon_resp, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "is_key_image_spent");
     THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "is_key_image_spent");
     THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::is_key_image_spent_error, daemon_resp.status);
     THROW_WALLET_EXCEPTION_IF(daemon_resp.spent_status.size() != signed_key_images.size(), error::wallet_internal_error,
       "daemon returned wrong response for is_key_image_spent, wrong amounts count = " +
       std::to_string(daemon_resp.spent_status.size()) + ", expected " +  std::to_string(signed_key_images.size()));
     for (size_t n = 0; n < daemon_resp.spent_status.size(); ++n)
     {
       transfer_details &td = m_transfers[n + offset];
       td.m_spent = daemon_resp.spent_status[n] != COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT;
     }
   }
   spent = 0;
   unspent = 0;
   std::unordered_set<crypto::hash> spent_txids;   // For each spent key image, search for a tx in m_transfers that uses it as input.
   std::vector<size_t> swept_transfers;            // If such a spending tx wasn't found in m_transfers, this means the spending tx 
                                                   // was created by sweep_all, so we can't know the spent height and other detailed info.
   std::unordered_map<crypto::key_image, crypto::hash> spent_key_images;
  
   PERF_TIMER_START(import_key_images_C);
   for (const transfer_details &td: m_transfers)
   {
     for (const cryptonote::txin_v& in : td.m_tx.vin)
     {
       if (in.type() == typeid(cryptonote::txin_to_key))
         spent_key_images.insert(std::make_pair(boost::get<cryptonote::txin_to_key>(in).k_image, td.m_txid));
     }
   }
   PERF_TIMER_STOP(import_key_images_C);
  
   // accumulate outputs before the updated data
   for(size_t i = 0; i < offset; ++i)
   {
     const transfer_details &td = m_transfers[i];
     if (td.m_frozen)
       continue;
     uint64_t amount = td.amount();
     if (td.m_spent)
       spent += amount;
     else
       unspent += amount;
   }
  
   PERF_TIMER_START(import_key_images_D);
   for(size_t i = 0; i < signed_key_images.size(); ++i)
   {
     const transfer_details &td = m_transfers[i + offset];
     if (td.m_frozen)
       continue;
     uint64_t amount = td.amount();
     if (td.m_spent)
       spent += amount;
     else
       unspent += amount;
     LOG_PRINT_L2("Transfer " << i << ": " << print_etn(amount) << " (" << td.m_global_output_index << "): "
         << (td.m_spent ? "spent" : "unspent") << " (key image " << req.key_images[i] << ")");
  
     if (i < daemon_resp.spent_status.size() && daemon_resp.spent_status[i] == COMMAND_RPC_IS_KEY_IMAGE_SPENT::SPENT_IN_BLOCKCHAIN)
     {
       const std::unordered_map<crypto::key_image, crypto::hash>::const_iterator skii = spent_key_images.find(td.m_key_image);
       if (skii == spent_key_images.end())
         swept_transfers.push_back(i);
       else
         spent_txids.insert(skii->second);
     }
   }
   PERF_TIMER_STOP(import_key_images_D);
  
   MDEBUG("Total: " << print_etn(spent) << " spent, " << print_etn(unspent) << " unspent");
  
   if (check_spent)
   {
     // query outgoing txes
     COMMAND_RPC_GET_TRANSACTIONS::request gettxs_req;
     COMMAND_RPC_GET_TRANSACTIONS::response gettxs_res;
     gettxs_req.decode_as_json = false;
     gettxs_req.prune = true;
     gettxs_req.txs_hashes.reserve(spent_txids.size());
     for (const crypto::hash& spent_txid : spent_txids)
       gettxs_req.txs_hashes.push_back(epee::string_tools::pod_to_hex(spent_txid));
  
  
     PERF_TIMER_START(import_key_images_E);
     m_daemon_rpc_mutex.lock();
     bool r = invoke_http_json("/gettransactions", gettxs_req, gettxs_res, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
     THROW_WALLET_EXCEPTION_IF(gettxs_res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
     THROW_WALLET_EXCEPTION_IF(gettxs_res.txs.size() != spent_txids.size(), error::wallet_internal_error,
       "daemon returned wrong response for gettransactions, wrong count = " + std::to_string(gettxs_res.txs.size()) + ", expected " + std::to_string(spent_txids.size()));
     PERF_TIMER_STOP(import_key_images_E);
  
     // process each outgoing tx
     PERF_TIMER_START(import_key_images_F);
     auto spent_txid = spent_txids.begin();
     hw::device &hwdev =  m_account.get_device();
     auto it = spent_txids.begin();
     for (const COMMAND_RPC_GET_TRANSACTIONS::entry& e : gettxs_res.txs)
     {
       THROW_WALLET_EXCEPTION_IF(e.in_pool, error::wallet_internal_error, "spent tx isn't supposed to be in txpool");
  
       cryptonote::transaction spent_tx;
       crypto::hash spnet_txid_parsed;
       THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(e, spent_tx, spnet_txid_parsed), error::wallet_internal_error, "Failed to get tx from daemon");
       THROW_WALLET_EXCEPTION_IF(!(spnet_txid_parsed == *it), error::wallet_internal_error, "parsed txid mismatch");
       ++it;
  
       // get received (change) amount
       uint64_t tx_etn_got_in_outs = 0;
       const cryptonote::account_keys& keys = m_account.get_keys();
       const crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(spent_tx);
       crypto::key_derivation derivation;
       bool r = hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation);
       THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
       const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(spent_tx);
       std::vector<crypto::key_derivation> additional_derivations;
       for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
       {
         additional_derivations.push_back({});
         r = hwdev.generate_key_derivation(additional_tx_pub_keys[i], keys.m_view_secret_key, additional_derivations.back());
         THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
       }
       size_t output_index = 0;
       bool miner_tx = cryptonote::is_coinbase(spent_tx);
       for (const cryptonote::tx_out& out : spent_tx.vout)
       {
         tx_scan_info_t tx_scan_info;
         check_acc_out_precomp(out, derivation, additional_derivations, output_index, tx_scan_info);
         THROW_WALLET_EXCEPTION_IF(tx_scan_info.error, error::wallet_internal_error, "check_acc_out_precomp failed");
         if (tx_scan_info.received)
         {
           if (tx_scan_info.etn_transfered == 0 && !miner_tx)
           {
             rct::key mask;
             tx_scan_info.etn_transfered = tools::decodeRct(spent_tx.rct_signatures, tx_scan_info.received->derivation, output_index, mask, hwdev);
           }
           THROW_WALLET_EXCEPTION_IF(tx_etn_got_in_outs >= std::numeric_limits<uint64_t>::max() - tx_scan_info.etn_transfered,
               error::wallet_internal_error, "Overflow in received amounts");
           tx_etn_got_in_outs += tx_scan_info.etn_transfered;
         }
         ++output_index;
       }
  
       // get spent amount
       uint64_t tx_etn_spent_in_ins = 0;
       uint32_t subaddr_account = (uint32_t)-1;
       std::set<uint32_t> subaddr_indices;
       for (const cryptonote::txin_v& in : spent_tx.vin)
       {
         if (in.type() != typeid(cryptonote::txin_to_key))
           continue;
         auto it = m_key_images.find(boost::get<cryptonote::txin_to_key>(in).k_image);
         if (it != m_key_images.end())
         {
           THROW_WALLET_EXCEPTION_IF(it->second >= m_transfers.size(), error::wallet_internal_error, std::string("Key images cache contains illegal transfer offset: ") + std::to_string(it->second) + std::string(" m_transfers.size() = ") + std::to_string(m_transfers.size()));
           const transfer_details& td = m_transfers[it->second];
           uint64_t amount = boost::get<cryptonote::txin_to_key>(in).amount;
           if (amount > 0)
           {
             THROW_WALLET_EXCEPTION_IF(amount != td.amount(), error::wallet_internal_error,
                 std::string("Inconsistent amount in tx input: got ") + print_etn(amount) +
                 std::string(", expected ") + print_etn(td.amount()));
           }
           amount = td.amount();
           tx_etn_spent_in_ins += amount;
  
           LOG_PRINT_L0("Spent ETN: " << print_etn(amount) << ", with tx: " << *spent_txid);
           set_spent(it->second, e.block_height);
           if (m_callback)
             m_callback->on_etn_spent(e.block_height, *spent_txid, spent_tx, amount, spent_tx, td.m_subaddr_index);
           if (subaddr_account != (uint32_t)-1 && subaddr_account != td.m_subaddr_index.major)
             LOG_PRINT_L0("WARNING: This tx spends outputs received by different subaddress accounts, which isn't supposed to happen");
           subaddr_account = td.m_subaddr_index.major;
           subaddr_indices.insert(td.m_subaddr_index.minor);
         }
       }
  
       // create outgoing payment
       process_outgoing(*spent_txid, spent_tx, e.block_height, e.block_timestamp, tx_etn_spent_in_ins, tx_etn_got_in_outs, subaddr_account, subaddr_indices);
  
       // erase corresponding incoming payment
       for (auto j = m_payments.begin(); j != m_payments.end(); ++j)
       {
         if (j->second.m_tx_hash == *spent_txid)
         {
           m_payments.erase(j);
           break;
         }
       }
  
       ++spent_txid;
     }
     PERF_TIMER_STOP(import_key_images_F);
  
     PERF_TIMER_START(import_key_images_G);
     for (size_t n : swept_transfers)
     {
       const transfer_details& td = m_transfers[n];
       confirmed_transfer_details pd;
       pd.m_change = (uint64_t)-1;                             // change is unknown
       pd.m_amount_in = pd.m_amount_out = td.amount();         // fee is unknown
       pd.m_block_height = 0;  // spent block height is unknown
       pd.m_is_migration = td.m_tx.version == 2;
       const crypto::hash &spent_txid = crypto::null_hash; // spent txid is unknown
       m_confirmed_txs.insert(std::make_pair(spent_txid, pd));
     }
     PERF_TIMER_STOP(import_key_images_G);
   }
  
   // this can be 0 if we do not know the height
   return m_transfers[signed_key_images.size() + offset - 1].m_block_height;
 }

Here is the call graph for this function:

◆ import_key_images() [3/4]

bool tools::wallet2::import_key_images	(	signed_tx_set &	signed_tx,
		size_t	offset = `0`,
		bool	only_selected_transfers = `false`
	)

Definition at line 12430 of file wallet2.cpp.

 {
   std::unordered_set<size_t> selected_transfers;
   if (only_selected_transfers)
   {
     for (const pending_tx & ptx : signed_tx.ptx)
     {
       for (const size_t s: ptx.selected_transfers)
         selected_transfers.insert(s);
     }
   }
  
   return import_key_images(signed_tx.key_images, offset, only_selected_transfers ? boost::make_optional(selected_transfers) : boost::none);
 }

◆ import_key_images() [4/4]

bool tools::wallet2::import_key_images	(	std::vector< crypto::key_image >	key_images,
		size_t	offset = `0`,
		boost::optional< std::unordered_set< size_t >>	selected_transfers = `boost::none`
	)

◆ import_multisig()

size_t tools::wallet2::import_multisig ( std::vector< cryptonote::blobdata > info )

Import a set of multisig info from multisig partners

Returns: the number of inputs which were imported

Definition at line 12847 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
  
   std::vector<std::vector<tools::wallet2::multisig_info>> info;
   std::unordered_set<crypto::public_key> seen;
   for (cryptonote::blobdata &data: blobs)
   {
     const size_t magiclen = strlen(MULTISIG_EXPORT_FILE_MAGIC);
     THROW_WALLET_EXCEPTION_IF(data.size() < magiclen || memcmp(data.data(), MULTISIG_EXPORT_FILE_MAGIC, magiclen),
         error::wallet_internal_error, "Bad multisig info file magic in ");
  
     data = decrypt_with_view_secret_key(std::string(data, magiclen));
  
     const size_t headerlen = 3 * sizeof(crypto::public_key);
     THROW_WALLET_EXCEPTION_IF(data.size() < headerlen, error::wallet_internal_error, "Bad data size");
  
     const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[0];
     const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[sizeof(crypto::public_key)];
     const crypto::public_key &signer = *(const crypto::public_key*)&data[2*sizeof(crypto::public_key)];
     const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
     THROW_WALLET_EXCEPTION_IF(public_spend_key != keys.m_spend_public_key || public_view_key != keys.m_view_public_key,
         error::wallet_internal_error, "Multisig info is for a different account");
     if (get_multisig_signer_public_key() == signer)
     {
       MINFO("Multisig info from this wallet ignored");
       continue;
     }
     if (seen.find(signer) != seen.end())
     {
       MINFO("Duplicate multisig info ignored");
       continue;
     }
     seen.insert(signer);
  
     std::string body(data, headerlen);
     std::istringstream iss(body);
     std::vector<tools::wallet2::multisig_info> i;
     boost::archive::portable_binary_iarchive ar(iss);
     ar >> i;
     MINFO(boost::format("%u outputs found") % boost::lexical_cast<std::string>(i.size()));
     info.push_back(std::move(i));
   }
  
   CHECK_AND_ASSERT_THROW_MES(info.size() + 1 <= m_multisig_signers.size() && info.size() + 1 >= m_multisig_threshold, "Wrong number of multisig sources");
  
   std::vector<std::vector<rct::key>> k;
   k.reserve(m_transfers.size());
   for (const auto &td: m_transfers)
     k.push_back(td.m_multisig_k);
  
   // how many outputs we're going to update
   size_t n_outputs = m_transfers.size();
   for (const auto &pi: info)
     if (pi.size() < n_outputs)
       n_outputs = pi.size();
  
   if (n_outputs == 0)
     return 0;
  
   // check signers are consistent
   for (const auto &pi: info)
   {
     CHECK_AND_ASSERT_THROW_MES(std::find(m_multisig_signers.begin(), m_multisig_signers.end(), pi[0].m_signer) != m_multisig_signers.end(),
         "Signer is not a member of this multisig wallet");
     for (size_t n = 1; n < n_outputs; ++n)
       CHECK_AND_ASSERT_THROW_MES(pi[n].m_signer == pi[0].m_signer, "Mismatched signers in imported multisig info");
   }
  
   // trim data we don't have info for from all participants
   for (auto &pi: info)
     pi.resize(n_outputs);
  
   // sort by signer
   if (!info.empty() && !info.front().empty())
   {
     std::sort(info.begin(), info.end(), [](const std::vector<tools::wallet2::multisig_info> &i0, const std::vector<tools::wallet2::multisig_info> &i1){ return memcmp(&i0[0].m_signer, &i1[0].m_signer, sizeof(i0[0].m_signer)); });
   }
  
   // first pass to determine where to detach the blockchain
   for (size_t n = 0; n < n_outputs; ++n)
   {
     const transfer_details &td = m_transfers[n];
     if (!td.m_key_image_partial)
       continue;
     MINFO("Multisig info importing from block height " << td.m_block_height);
     detach_blockchain(td.m_block_height);
     break;
   }
  
   for (size_t n = 0; n < n_outputs && n < m_transfers.size(); ++n)
   {
     update_multisig_rescan_info(k, info, n);
   }
  
   m_multisig_rescan_k = &k;
   m_multisig_rescan_info = &info;
   try
   {
  
     refresh(false);
   }
   catch (...)
   {
     m_multisig_rescan_info = NULL;
     m_multisig_rescan_k = NULL;
     throw;
   }
   m_multisig_rescan_info = NULL;
   m_multisig_rescan_k = NULL;
  
   return n_outputs;
 }

Here is the call graph for this function:

◆ import_outputs()

size_t tools::wallet2::import_outputs ( const std::pair< size_t, std::vector< tools::wallet2::transfer_details >> & outputs )

Definition at line 12543 of file wallet2.cpp.

 {
   PERF_TIMER(import_outputs);
  
   THROW_WALLET_EXCEPTION_IF(outputs.first > m_transfers.size(), error::wallet_internal_error,
       "Imported outputs omit more outputs that we know of");
  
   const size_t offset = outputs.first;
   const size_t original_size = m_transfers.size();
   m_transfers.resize(offset + outputs.second.size());
   for (size_t i = 0; i < offset; ++i)
     m_transfers[i].m_key_image_request = false;
   for (size_t i = 0; i < outputs.second.size(); ++i)
   {
     transfer_details td = outputs.second[i];
  
     // skip those we've already imported, or which have different data
     if (i + offset < original_size)
     {
       // compare the data used to create the key image below
       const transfer_details &org_td = m_transfers[i + offset];
       if (!org_td.m_key_image_known)
         goto process;
 #define CMPF(f) if (!(td.f == org_td.f)) goto process
       CMPF(m_txid);
       CMPF(m_key_image);
       CMPF(m_internal_output_index);
 #undef CMPF
       if (!(get_transaction_prefix_hash(td.m_tx) == get_transaction_prefix_hash(org_td.m_tx)))
         goto process;
  
       // copy anyway, since the comparison does not include ancillary fields which may have changed
       m_transfers[i + offset] = std::move(td);
       continue;
     }
  
 process:
  
     // the hot wallet wouldn't have known about key images (except if we already exported them)
     cryptonote::keypair in_ephemeral;
  
     THROW_WALLET_EXCEPTION_IF(td.m_tx.vout.empty(), error::wallet_internal_error, "tx with no outputs at index " + boost::lexical_cast<std::string>(i + offset));
     crypto::public_key tx_pub_key = get_tx_pub_key_from_received_outs(td);
     const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
  
     THROW_WALLET_EXCEPTION_IF(td.m_tx.vout[td.m_internal_output_index].target.type() != typeid(cryptonote::txout_to_key),
         error::wallet_internal_error, "Unsupported output type");
     const crypto::public_key& out_key = boost::get<cryptonote::txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key;
     bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, out_key, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, td.m_key_image, m_account.get_device(), m_account_major_offset);
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
     expand_subaddresses(td.m_subaddr_index);
     td.m_key_image_known = true;
     td.m_key_image_request = true;
     td.m_key_image_partial = false;
     THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != out_key,
         error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key at index " + boost::lexical_cast<std::string>(i + offset));
  
     m_key_images[td.m_key_image] = i + offset;
     m_pub_keys[td.get_public_key()] = i + offset;
     m_transfers[i + offset] = std::move(td);
   }
  
   return m_transfers.size();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ import_outputs_from_str()

size_t tools::wallet2::import_outputs_from_str ( const std::string & outputs_st )

Definition at line 12608 of file wallet2.cpp.

 {
   PERF_TIMER(import_outputs_from_str);
   std::string data = outputs_st;
   const size_t magiclen = strlen(OUTPUT_EXPORT_FILE_MAGIC);
   if (data.size() < magiclen || memcmp(data.data(), OUTPUT_EXPORT_FILE_MAGIC, magiclen))
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Bad magic from outputs"));
   }
  
   try
   {
     PERF_TIMER(import_outputs_decrypt);
     data = decrypt_with_view_secret_key(std::string(data, magiclen));
   }
   catch (const std::exception &e)
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Failed to decrypt outputs: ") + e.what());
   }
  
   const size_t headerlen = 2 * sizeof(crypto::public_key);
   if (data.size() < headerlen)
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Bad data size for outputs"));
   }
   const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[0];
   const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[sizeof(crypto::public_key)];
   const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
   if (public_spend_key != keys.m_spend_public_key || public_view_key != keys.m_view_public_key)
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Outputs from are for a different account"));
   }
  
   size_t imported_outputs = 0;
   try
   {
     std::string body(data, headerlen);
     std::stringstream iss;
     iss << body;
     std::pair<size_t, std::vector<tools::wallet2::transfer_details>> outputs;
     try
     {
       boost::archive::portable_binary_iarchive ar(iss);
       ar >> outputs;
     }
     catch (...)
     {
       iss.str("");
       iss << body;
       boost::archive::binary_iarchive ar(iss);
       ar >> outputs;
     }
  
     imported_outputs = import_outputs(outputs);
   }
   catch (const std::exception &e)
   {
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Failed to import outputs") + e.what());
   }
  
   return imported_outputs;
 }

◆ import_payments()

void tools::wallet2::import_payments ( const payment_container & payments )

Definition at line 12454 of file wallet2.cpp.

 {
   m_payments.clear();
   for (auto const &p : payments)
   {
     m_payments.emplace(p);
   }
 }

◆ import_payments_out()

void tools::wallet2::import_payments_out ( const std::list< std::pair< crypto::hash, wallet2::confirmed_transfer_details >> & confirmed_payments )

Definition at line 12462 of file wallet2.cpp.

 {
   m_confirmed_txs.clear();
   for (auto const &p : confirmed_payments)
   {
     m_confirmed_txs.emplace(p);
   }
 }

◆ init()

bool tools::wallet2::init	(	std::string	daemon_address = `"http://localhost:8080"`,
		boost::optional< epee::net_utils::http::login >	daemon_login = `boost::none`,
		boost::asio::ip::tcp::endpoint	proxy = `{}`,
		uint64_t	upper_transaction_weight_limit = `0`,
		bool	trusted_daemon = `true`,
		epee::net_utils::ssl_options_t	ssl_options = `epee::net_utils::ssl_support_t::e_ssl_support_autodetect`,
		std::string	blockchain_db_path = `""`
	)

Definition at line 1281 of file wallet2.cpp.

 {
   m_checkpoints.init_default_checkpoints(m_nettype);
   m_is_initialized = true;
   m_upper_transaction_weight_limit = upper_transaction_weight_limit;
  
   if (proxy != boost::asio::ip::tcp::endpoint{})
     m_http_client.set_connector(net::socks::connector{std::move(proxy)});
   return set_daemon(daemon_address, daemon_login, trusted_daemon, std::move(ssl_options));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_options()

void tools::wallet2::init_options ( boost::program_options::options_description & desc_params )

static

Definition at line 1192 of file wallet2.cpp.

 {
   const options opts{};
   command_line::add_arg(desc_params, opts.daemon_address);
   command_line::add_arg(desc_params, opts.daemon_host);
   command_line::add_arg(desc_params, opts.proxy);
   command_line::add_arg(desc_params, opts.trusted_daemon);
   command_line::add_arg(desc_params, opts.untrusted_daemon);
   command_line::add_arg(desc_params, opts.password);
   command_line::add_arg(desc_params, opts.password_file);
   command_line::add_arg(desc_params, opts.daemon_port);
   command_line::add_arg(desc_params, opts.daemon_login);
   command_line::add_arg(desc_params, opts.daemon_ssl);
   command_line::add_arg(desc_params, opts.daemon_ssl_private_key);
   command_line::add_arg(desc_params, opts.daemon_ssl_certificate);
   command_line::add_arg(desc_params, opts.daemon_ssl_ca_certificates);
   command_line::add_arg(desc_params, opts.daemon_ssl_allowed_fingerprints);
   command_line::add_arg(desc_params, opts.daemon_ssl_allow_any_cert);
   command_line::add_arg(desc_params, opts.daemon_ssl_allow_chained);
   command_line::add_arg(desc_params, opts.testnet);
   command_line::add_arg(desc_params, opts.stagenet);
   command_line::add_arg(desc_params, opts.shared_ringdb_dir);
   command_line::add_arg(desc_params, opts.kdf_rounds);
   mms::message_store::init_options(desc_params);
   command_line::add_arg(desc_params, opts.hw_device);
   command_line::add_arg(desc_params, opts.hw_device_derivation_path);
   command_line::add_arg(desc_params, opts.tx_notify);
   command_line::add_arg(desc_params, opts.no_dns);
   command_line::add_arg(desc_params, opts.offline);
   command_line::add_arg(desc_params, opts.data_dir);
   command_line::add_arg(desc_params, opts.fallback_to_pow_checkpoint_height);
   command_line::add_arg(desc_params, opts.fallback_to_pow_checkpoint_hash);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invoke_http_bin()

template<class t_request , class t_response >

bool tools::wallet2::invoke_http_bin	(	const boost::string_ref	uri,
		const t_request &	req,
		t_response &	res,
		std::chrono::milliseconds	timeout = `std::chrono::seconds(15)`,
		const boost::string_ref	http_method = `"GET"`
	)

inline

Definition at line 1318 of file wallet2.h.

     {
       if (m_offline) return false;
       boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
       return epee::net_utils::invoke_http_bin(uri, req, res, m_http_client, timeout, http_method);
     }

Here is the call graph for this function:

◆ invoke_http_json()

template<class t_request , class t_response >

bool tools::wallet2::invoke_http_json	(	const boost::string_ref	uri,
		const t_request &	req,
		t_response &	res,
		std::chrono::milliseconds	timeout = `std::chrono::seconds(15)`,
		const boost::string_ref	http_method = `"GET"`
	)

inline

Definition at line 1311 of file wallet2.h.

     {
       if (m_offline) return false;
       boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
       return epee::net_utils::invoke_http_json(uri, req, res, m_http_client, timeout, http_method);
     }

Here is the call graph for this function:

◆ invoke_http_json_rpc()

template<class t_request , class t_response >

bool tools::wallet2::invoke_http_json_rpc	(	const boost::string_ref	uri,
		const std::string &	method_name,
		const t_request &	req,
		t_response &	res,
		std::chrono::milliseconds	timeout = `std::chrono::seconds(15)`,
		const boost::string_ref	http_method = `"GET"`,
		const std::string &	req_id = `"0"`
	)

inline

Definition at line 1325 of file wallet2.h.

     {
       if (m_offline) return false;
       boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
       return epee::net_utils::invoke_http_json_rpc(uri, method_name, req, res, m_http_client, timeout, http_method, req_id);
     }

Here is the call graph for this function:

◆ is_deprecated()

bool tools::wallet2::is_deprecated ( ) const

Tells if the wallet file is deprecated.

Definition at line 1545 of file wallet2.cpp.

 {
   return is_old_file_format;
 }

◆ is_deterministic()

bool tools::wallet2::is_deterministic ( ) const

Checks if deterministic wallet.

Definition at line 1292 of file wallet2.cpp.

 {
   crypto::secret_key second;
   keccak((uint8_t *)&get_account().get_keys().m_spend_secret_key, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
   sc_reduce32((uint8_t *)&second);
   return memcmp(second.data,get_account().get_keys().m_view_secret_key.data, sizeof(crypto::secret_key)) == 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_keys_file_locked()

bool tools::wallet2::is_keys_file_locked ( ) const

Definition at line 8026 of file wallet2.cpp.

 {
   return m_keys_file_locker->locked();
 }

◆ is_output_blackballed()

bool tools::wallet2::is_output_blackballed ( const std::pair< uint64_t, uint64_t > & output ) const

Definition at line 7996 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
   try { return m_ringdb->blackballed(output); }
   catch (const std::exception &e) { return false; }
 }

◆ is_synced()

bool tools::wallet2::is_synced ( ) const

Definition at line 13260 of file wallet2.cpp.

 {
   uint64_t height;
   boost::optional<std::string> result = m_node_rpc_proxy.get_target_height(height);
   if (result && *result != CORE_RPC_STATUS_OK)
     return false;
   return get_blockchain_current_height() >= height;
 }

◆ is_transfer_unlocked() [1/2]

bool tools::wallet2::is_transfer_unlocked ( const transfer_details & td ) const

Definition at line 6364 of file wallet2.cpp.

 {
   return is_transfer_unlocked(td.m_tx.unlock_time, td.m_block_height);
 }

◆ is_transfer_unlocked() [2/2]

bool tools::wallet2::is_transfer_unlocked	(	uint64_t	unlock_time,
		uint64_t	block_height
	)		const

Definition at line 6369 of file wallet2.cpp.

 {
   if(!is_tx_spendtime_unlocked(unlock_time, block_height))
     return false;
  
   uint64_t v8height = m_nettype == TESTNET ? 446674 : 589169;
   uint16_t UNLOCK_WINDOW = block_height > v8height ? ETN_DEFAULT_TX_SPENDABLE_AGE_V8 : CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE;
   
   if(block_height + UNLOCK_WINDOW > get_blockchain_current_height())
     return false;
  
   return true;
 }

◆ is_trusted_daemon()

bool tools::wallet2::is_trusted_daemon ( ) const

inline

Definition at line 759 of file wallet2.h.

759 { return m_trusted_daemon; }

Here is the caller graph for this function:

◆ is_tx_spendtime_unlocked()

bool tools::wallet2::is_tx_spendtime_unlocked	(	uint64_t	unlock_time,
		uint64_t	block_height
	)		const

Definition at line 6383 of file wallet2.cpp.

 {
   if(unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER)
   {
     //interpret as block index
     if(get_blockchain_current_height()-1 + CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS >= unlock_time)
       return true;
     else
       return false;
   }else
   {
     //interpret as time
     uint64_t current_time = static_cast<uint64_t>(time(NULL));
     // XXX: this needs to be fast, so we'd need to get the starting heights
     // from the daemon to be correct once voting kicks in
     uint64_t v6height = m_nettype == TESTNET ? 190059 : 307499;
     uint64_t leeway = block_height > v6height ? CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V6 : CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS;
     if(current_time + leeway >= unlock_time)
       return true;
     else
       return false;
   }
   return false;
 }

◆ is_unattended()

bool tools::wallet2::is_unattended ( ) const

inline

Definition at line 1266 of file wallet2.h.

1266 { return m_unattended; }

Here is the caller graph for this function:

◆ key_on_device()

bool tools::wallet2::key_on_device ( ) const

inline

Definition at line 824 of file wallet2.h.

824 { return get_device_type() != hw::device::device_type::SOFTWARE; }

tools::wallet2::get_device_type

hw::device::device_type get_device_type() const

Definition: wallet2.h:825

Here is the call graph for this function:

◆ key_reuse_mitigation2() [1/2]

bool tools::wallet2::key_reuse_mitigation2 ( ) const

inline

Definition at line 1089 of file wallet2.h.

1089 { return m_key_reuse_mitigation2; }

◆ key_reuse_mitigation2() [2/2]

void tools::wallet2::key_reuse_mitigation2 ( bool value )

inline

Definition at line 1090 of file wallet2.h.

1090 { m_key_reuse_mitigation2 = value; }

◆ light_wallet()

bool tools::wallet2::light_wallet ( ) const

inline

Checks if light wallet. A light wallet sends view key to a server where the blockchain is scanned.

Definition at line 771 of file wallet2.h.

771 { return m_light_wallet; }

Here is the caller graph for this function:

◆ light_wallet_get_address_info()

bool tools::wallet2::light_wallet_get_address_info ( tools::COMMAND_RPC_GET_ADDRESS_INFO::response & response )

Definition at line 9228 of file wallet2.cpp.

 {
   MTRACE(__FUNCTION__);
   
   tools::COMMAND_RPC_GET_ADDRESS_INFO::request request;
   
   request.address = get_account().get_public_address_str(m_nettype);
   request.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json("/get_address_info", request, response, rpc_timeout, "POST");
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_address_info");
   // TODO: Validate result
   return true;
 }

Here is the call graph for this function:

◆ light_wallet_get_address_txs()

void tools::wallet2::light_wallet_get_address_txs ( )

Definition at line 9244 of file wallet2.cpp.

 {
   MDEBUG("Refreshing light wallet");
   
   tools::COMMAND_RPC_GET_ADDRESS_TXS::request ireq;
   tools::COMMAND_RPC_GET_ADDRESS_TXS::response ires;
   
   ireq.address = get_account().get_public_address_str(m_nettype);
   ireq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json("/get_address_txs", ireq, ires, rpc_timeout, "POST");
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_address_txs");
   //OpenMonero sends status=success, Mymonero doesn't. 
   THROW_WALLET_EXCEPTION_IF((!ires.status.empty() && ires.status != "success"), error::no_connection_to_daemon, "get_address_txs");
  
   
   // Abort if no transactions
   if(ires.transactions.empty())
     return;
   
   // Create searchable vectors
   std::vector<crypto::hash> payments_txs;
   for(const auto &p: m_payments)
     payments_txs.push_back(p.second.m_tx_hash);
   std::vector<crypto::hash> unconfirmed_payments_txs;
   for(const auto &up: m_unconfirmed_payments)
     unconfirmed_payments_txs.push_back(up.second.m_pd.m_tx_hash);
  
   // for balance calculation
   uint64_t wallet_total_sent = 0;
   // txs in pool
   std::vector<crypto::hash> pool_txs;
  
   for (const auto &t: ires.transactions) {
     const uint64_t total_received = t.total_received;
     uint64_t total_sent = t.total_sent;
  
     // Check key images - subtract fake outputs from total_sent
     for(const auto &so: t.spent_outputs)
     {
       crypto::public_key tx_public_key;
       crypto::key_image key_image;
       THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, so.tx_pub_key), error::wallet_internal_error, "Invalid tx_pub_key field");
       THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, so.key_image), error::wallet_internal_error, "Invalid key_image field");
       string_tools::hex_to_pod(so.tx_pub_key, tx_public_key);
       string_tools::hex_to_pod(so.key_image, key_image);
  
       if(!light_wallet_key_image_is_ours(key_image, tx_public_key, so.out_index)) {
         THROW_WALLET_EXCEPTION_IF(so.amount > t.total_sent, error::wallet_internal_error, "Lightwallet: total sent is negative!");
         total_sent -= so.amount;
       }
     }
  
     // Do not add tx if empty. 
     if(total_sent == 0 && total_received == 0)
       continue;
     
     crypto::hash payment_id = null_hash;
     crypto::hash tx_hash;
     
     THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, t.payment_id), error::wallet_internal_error, "Invalid payment_id field");
     THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, t.hash), error::wallet_internal_error, "Invalid hash field");
     string_tools::hex_to_pod(t.payment_id, payment_id);
     string_tools::hex_to_pod(t.hash, tx_hash);
  
     // lightwallet specific info
     bool incoming = (total_received > total_sent);
     address_tx address_tx;
     address_tx.m_tx_hash = tx_hash;
     address_tx.m_incoming = incoming;
     address_tx.m_amount  =  incoming ? total_received - total_sent : total_sent - total_received;
     address_tx.m_fee = 0;                 // TODO
     address_tx.m_block_height = t.height;
     address_tx.m_unlock_time  = t.unlock_time;
     address_tx.m_timestamp = t.timestamp;
     address_tx.m_coinbase  = t.coinbase;
     address_tx.m_mempool  = t.mempool;
     m_light_wallet_address_txs.emplace(tx_hash,address_tx);
  
     // populate data needed for history (m_payments, m_unconfirmed_payments, m_confirmed_txs)
     // INCOMING transfers
     if(total_received > total_sent) {
       payment_details payment;
       payment.m_tx_hash = tx_hash;
       payment.m_amount       = total_received - total_sent;
       payment.m_fee          = 0;         // TODO
       payment.m_block_height = t.height;
       payment.m_unlock_time  = t.unlock_time;
       payment.m_timestamp = t.timestamp;
       payment.m_coinbase = t.coinbase;
         
       if (t.mempool) {   
         if (std::find(unconfirmed_payments_txs.begin(), unconfirmed_payments_txs.end(), tx_hash) == unconfirmed_payments_txs.end()) {
           pool_txs.push_back(tx_hash);
           // assume false as we don't get that info from the light wallet server
           crypto::hash payment_id;
           THROW_WALLET_EXCEPTION_IF(!epee::string_tools::hex_to_pod(t.payment_id, payment_id),
               error::wallet_internal_error, "Failed to parse payment id");
           emplace_or_replace(m_unconfirmed_payments, payment_id, pool_payment_details{payment, false, false});
           if (0 != m_callback) {
             m_callback->on_lw_unconfirmed_etn_received(t.height, payment.m_tx_hash, payment.m_amount);
           }
         }
       } else {
         if (std::find(payments_txs.begin(), payments_txs.end(), tx_hash) == payments_txs.end()) {
           m_payments.emplace(tx_hash, payment);
           if (0 != m_callback) {
             m_callback->on_lw_etn_received(t.height, payment.m_tx_hash, payment.m_amount);
           }
         }
       }
     // Outgoing transfers
     } else {
       uint64_t amount_sent = total_sent - total_received;
       cryptonote::transaction dummy_tx; // not used by light wallet
       // increase wallet total sent
       wallet_total_sent += total_sent;
       if (t.mempool)
       {
         // Handled by add_unconfirmed_tx in commit_tx
         // If sent from another wallet instance we need to add it
         if(m_unconfirmed_txs.find(tx_hash) == m_unconfirmed_txs.end())
         {
           unconfirmed_transfer_details utd;
           utd.m_amount_in = amount_sent;
           utd.m_amount_out = amount_sent;
           utd.m_change = 0;
           utd.m_payment_id = payment_id;
           utd.m_timestamp = t.timestamp;
           utd.m_state = wallet2::unconfirmed_transfer_details::pending;
           m_unconfirmed_txs.emplace(tx_hash,utd);
         }
       }
       else
       {
         // Only add if new
         auto confirmed_tx = m_confirmed_txs.find(tx_hash);
         if(confirmed_tx == m_confirmed_txs.end()) {
           // tx is added to m_unconfirmed_txs - move to confirmed
           if(m_unconfirmed_txs.find(tx_hash) != m_unconfirmed_txs.end()) 
           { 
             process_unconfirmed(tx_hash, dummy_tx, t.height);
           }
           // Tx sent by another wallet instance
           else
           {
             confirmed_transfer_details ctd;
             ctd.m_amount_in = amount_sent;
             ctd.m_amount_out = amount_sent;
             ctd.m_change = 0;
             ctd.m_payment_id = payment_id;
             ctd.m_block_height = t.height;
             ctd.m_timestamp = t.timestamp;
             m_confirmed_txs.emplace(tx_hash,ctd);
           }
           if (0 != m_callback)
           {
             m_callback->on_lw_etn_spent(t.height, tx_hash, amount_sent);
           } 
         }
         // If not new - check the amount and update if necessary.
         // when sending a tx to same wallet the receiving amount has to be credited
         else
         {
           if(confirmed_tx->second.m_amount_in != amount_sent || confirmed_tx->second.m_amount_out != amount_sent)
           {
             MDEBUG("Adjusting amount sent/received for tx: <" + t.hash + ">. Is tx sent to own wallet? " << print_etn(amount_sent) << " != " << print_etn(confirmed_tx->second.m_amount_in));
             confirmed_tx->second.m_amount_in = amount_sent;
             confirmed_tx->second.m_amount_out = amount_sent;
             confirmed_tx->second.m_change = 0;
           }
         }
       }
     }    
   }
   // TODO: purge old unconfirmed_txs
   remove_obsolete_pool_txs(pool_txs);
  
   // Calculate wallet balance
   m_light_wallet_balance = ires.total_received-wallet_total_sent;
   // MyMonero doesn't send unlocked balance
   if(ires.total_received_unlocked > 0)
     m_light_wallet_unlocked_balance = ires.total_received_unlocked-wallet_total_sent;
   else
     m_light_wallet_unlocked_balance = m_light_wallet_balance;
 }

Here is the call graph for this function:

◆ light_wallet_get_outs()

void tools::wallet2::light_wallet_get_outs	(	std::vector< std::vector< get_outs_entry >> &	outs,
		const std::vector< size_t > &	selected_transfers,
		size_t	fake_outputs_count
	)

Definition at line 8058 of file wallet2.cpp.

                                                                                                                                                                   {
   
   MDEBUG("LIGHTWALLET - Getting random outs");
       
   cryptonote::COMMAND_RPC_GET_RANDOM_OUTS::request oreq;
   cryptonote::COMMAND_RPC_GET_RANDOM_OUTS::response ores;
   
   size_t light_wallet_requested_outputs_count = (size_t)((fake_outputs_count + 1) * 1.5 + 1);
   
   // Amounts to ask for
   // MyMonero api handle amounts and fees as strings
   for(size_t idx: selected_transfers) {
     const uint64_t ask_amount = m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount();
     std::ostringstream amount_ss;
     amount_ss << ask_amount;
     oreq.amounts.push_back(amount_ss.str());
   }
   
   oreq.count = light_wallet_requested_outputs_count;
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json("/get_random_outs", oreq, ores, rpc_timeout, "POST");
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_random_outs");
   THROW_WALLET_EXCEPTION_IF(ores.amount_outs.empty() , error::wallet_internal_error, "No outputs received from light wallet node. Error: " + ores.Error);
   
   // Check if we got enough outputs for each amount
   for(auto& out: ores.amount_outs) {
     const uint64_t out_amount = boost::lexical_cast<uint64_t>(out.amount);
     THROW_WALLET_EXCEPTION_IF(out.outputs.size() < light_wallet_requested_outputs_count , error::wallet_internal_error, "Not enough outputs for amount: " + boost::lexical_cast<std::string>(out.amount));
     MDEBUG(out.outputs.size() << " outputs for amount "+ boost::lexical_cast<std::string>(out.amount) + " received from light wallet node");
   }
  
   MDEBUG("selected transfers size: " << selected_transfers.size());
  
   for(size_t idx: selected_transfers)
   { 
     // Create new index
     outs.push_back(std::vector<get_outs_entry>());
     outs.back().reserve(fake_outputs_count + 1);
     
     // add real output first
     const transfer_details &td = m_transfers[idx];
     const uint64_t amount = td.is_rct() ? 0 : td.amount();
     outs.back().push_back(std::make_tuple(td.m_global_output_index, td.get_public_key(), rct::commit(td.amount(), td.m_mask)));
     MDEBUG("added real output " << string_tools::pod_to_hex(td.get_public_key()));
     
     // Even if the lightwallet server returns random outputs, we pick them randomly.
     std::vector<size_t> order;
     order.resize(light_wallet_requested_outputs_count);
     for (size_t n = 0; n < order.size(); ++n)
       order[n] = n;
     std::shuffle(order.begin(), order.end(), std::default_random_engine(crypto::rand<unsigned>()));
     
     
     LOG_PRINT_L2("Looking for " << (fake_outputs_count+1) << " outputs with amounts " << print_etn(td.is_rct() ? 0 : td.amount()));
     MDEBUG("OUTS SIZE: " << outs.back().size());
     for (size_t o = 0; o < light_wallet_requested_outputs_count && outs.back().size() < fake_outputs_count + 1; ++o)
     {
       // Random pick
       size_t i = order[o];
              
       // Find which random output key to use
       bool found_amount = false;
       size_t amount_key;
       for(amount_key = 0; amount_key < ores.amount_outs.size(); ++amount_key)
       {
         if(boost::lexical_cast<uint64_t>(ores.amount_outs[amount_key].amount) == amount) {
           found_amount = true;
           break;
         }
       }
       THROW_WALLET_EXCEPTION_IF(!found_amount , error::wallet_internal_error, "Outputs for amount " + boost::lexical_cast<std::string>(ores.amount_outs[amount_key].amount) + " not found" );
  
       LOG_PRINT_L2("Index " << i << "/" << light_wallet_requested_outputs_count << ": idx " << ores.amount_outs[amount_key].outputs[i].global_index << " (real " << td.m_global_output_index << "), unlocked " << "(always in light)" << ", key " << ores.amount_outs[0].outputs[i].public_key);
       
       // Convert light wallet string data to proper data structures
       crypto::public_key tx_public_key;
       rct::key mask = AUTO_VAL_INIT(mask); // decrypted mask - not used here
       rct::key rct_commit = AUTO_VAL_INIT(rct_commit);
       THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, ores.amount_outs[amount_key].outputs[i].public_key), error::wallet_internal_error, "Invalid public_key");
       string_tools::hex_to_pod(ores.amount_outs[amount_key].outputs[i].public_key, tx_public_key);
       const uint64_t global_index = ores.amount_outs[amount_key].outputs[i].global_index;
       if(!light_wallet_parse_rct_str(ores.amount_outs[amount_key].outputs[i].rct, tx_public_key, 0, mask, rct_commit, false))
         rct_commit = rct::zeroCommit(td.amount());
       
       if (tx_add_fake_output(outs, global_index, tx_public_key, rct_commit, td.m_global_output_index, true)) {
         MDEBUG("added fake output " << ores.amount_outs[amount_key].outputs[i].public_key);
         MDEBUG("index " << global_index);
       }
     }
  
     THROW_WALLET_EXCEPTION_IF(outs.back().size() < fake_outputs_count + 1 , error::wallet_internal_error, "Not enough fake outputs found" );
     
     // Real output is the first. Shuffle outputs
     MTRACE(outs.back().size() << " outputs added. Sorting outputs by index:");
     std::sort(outs.back().begin(), outs.back().end(), [](const get_outs_entry &a, const get_outs_entry &b) { return std::get<0>(a) < std::get<0>(b); });
  
     // Print output order
     for(auto added_out: outs.back())
       MTRACE(std::get<0>(added_out));
  
   }
 }

Here is the call graph for this function:

◆ light_wallet_get_unspent_outs()

void tools::wallet2::light_wallet_get_unspent_outs ( )

Definition at line 9074 of file wallet2.cpp.

 {
   MDEBUG("Getting unspent outs");
   
   tools::COMMAND_RPC_GET_UNSPENT_OUTS::request oreq;
   tools::COMMAND_RPC_GET_UNSPENT_OUTS::response ores;
   
   oreq.amount = "0";
   oreq.address = get_account().get_public_address_str(m_nettype);
   oreq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
   // openMonero specific
   oreq.dust_threshold = boost::lexical_cast<std::string>(::config::DEFAULT_DUST_THRESHOLD);
   // below are required by openMonero api - but are not used.
   oreq.mixin = 0;
   oreq.use_dust = true;
  
  
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json("/get_unspent_outs", oreq, ores, rpc_timeout, "POST");
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_unspent_outs");
   THROW_WALLET_EXCEPTION_IF(ores.status == "error", error::wallet_internal_error, ores.reason);
   
   m_light_wallet_per_kb_fee = ores.per_kb_fee;
   
   std::unordered_map<crypto::hash,bool> transfers_txs;
   for(const auto &t: m_transfers)
     transfers_txs.emplace(t.m_txid,t.m_spent);
   
   MDEBUG("FOUND " << ores.outputs.size() <<" outputs");
   
   // return if no outputs found
   if(ores.outputs.empty())
     return;
   
   // Clear old outputs
   m_transfers.clear();
   
   for (const auto &o: ores.outputs) {
     bool spent = false;
     bool add_transfer = true;
     crypto::key_image unspent_key_image;
     crypto::public_key tx_public_key = AUTO_VAL_INIT(tx_public_key);
     THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.tx_pub_key), error::wallet_internal_error, "Invalid tx_pub_key field");
     string_tools::hex_to_pod(o.tx_pub_key, tx_public_key);
     
     for (const std::string &ski: o.spend_key_images) {
       spent = false;
  
       // Check if key image is ours
       THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, ski), error::wallet_internal_error, "Invalid key image");
       string_tools::hex_to_pod(ski, unspent_key_image);
       if(light_wallet_key_image_is_ours(unspent_key_image, tx_public_key, o.index)){
         MTRACE("Output " << o.public_key << " is spent. Key image: " <<  ski);
         spent = true;
         break;
       } {
         MTRACE("Unspent output found. " << o.public_key);
       }
     }
  
     // Check if tx already exists in m_transfers. 
     crypto::hash txid;
     crypto::public_key tx_pub_key;
     crypto::public_key public_key;
     THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.tx_hash), error::wallet_internal_error, "Invalid tx_hash field");
     THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.public_key), error::wallet_internal_error, "Invalid public_key field");
     THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.tx_pub_key), error::wallet_internal_error, "Invalid tx_pub_key field");
     string_tools::hex_to_pod(o.tx_hash, txid);
     string_tools::hex_to_pod(o.public_key, public_key);
     string_tools::hex_to_pod(o.tx_pub_key, tx_pub_key);
     
     for(auto &t: m_transfers){
       if(t.get_public_key() == public_key) {
         t.m_spent = spent;
         add_transfer = false;
         break;
       }
     }
     
     if(!add_transfer)
       continue;
     
     m_transfers.push_back(boost::value_initialized<transfer_details>());
     transfer_details& td = m_transfers.back();
     
     td.m_block_height = o.height;
     td.m_global_output_index = o.global_index;
     td.m_txid = txid;
      
     // Add to extra
     add_tx_pub_key_to_extra(td.m_tx, tx_pub_key);
     
     td.m_key_image = unspent_key_image;
     td.m_key_image_known = !m_watch_only && !m_multisig;
     td.m_key_image_request = false;
     td.m_key_image_partial = m_multisig;
     td.m_amount = o.amount;
     td.m_pk_index = 0;
     td.m_internal_output_index = o.index;
     td.m_spent = spent;
     td.m_frozen = false;
  
     tx_out txout;
     txout.target = txout_to_key(public_key);
     txout.amount = td.m_amount;
     
     td.m_tx.vout.resize(td.m_internal_output_index + 1);
     td.m_tx.vout[td.m_internal_output_index] = txout;
     
     // Add unlock time and coinbase bool got from get_address_txs api call
     std::unordered_map<crypto::hash,address_tx>::const_iterator found = m_light_wallet_address_txs.find(txid);
     THROW_WALLET_EXCEPTION_IF(found == m_light_wallet_address_txs.end(), error::wallet_internal_error, "Lightwallet: tx not found in m_light_wallet_address_txs");
     bool miner_tx = found->second.m_coinbase;
     td.m_tx.unlock_time = found->second.m_unlock_time;
  
     if (!o.rct.empty())
     {
       // Coinbase tx's
       if(miner_tx)
       {
         td.m_mask = rct::identity();
       }
       else
       {
         // rct txs
         // decrypt rct mask, calculate commit hash and compare against blockchain commit hash
         rct::key rct_commit;
         light_wallet_parse_rct_str(o.rct, tx_pub_key, td.m_internal_output_index, td.m_mask, rct_commit, true);
         bool valid_commit = (rct_commit == rct::commit(td.amount(), td.m_mask));
         if(!valid_commit)
         {
           MDEBUG("output index: " << o.global_index);
           MDEBUG("mask: " + string_tools::pod_to_hex(td.m_mask));
           MDEBUG("calculated commit: " + string_tools::pod_to_hex(rct::commit(td.amount(), td.m_mask)));
           MDEBUG("expected commit: " + string_tools::pod_to_hex(rct_commit));
           MDEBUG("amount: " << td.amount());
         }
         THROW_WALLET_EXCEPTION_IF(!valid_commit, error::wallet_internal_error, "Lightwallet: rct commit hash mismatch!");
       }
       td.m_rct = true;
     }
     else
     {
       td.m_mask = rct::identity();
       td.m_rct = false;
     }
     if(!spent)
       set_unspent(m_transfers.size()-1);
     m_key_images[td.m_key_image] = m_transfers.size()-1;
     m_pub_keys[td.get_public_key()] = m_transfers.size()-1;
   }
 }

Here is the call graph for this function:

◆ light_wallet_import_wallet_request()

bool tools::wallet2::light_wallet_import_wallet_request ( tools::COMMAND_RPC_IMPORT_WALLET_REQUEST::response & response )

Definition at line 9059 of file wallet2.cpp.

 {
   MDEBUG("Light wallet import wallet request");
   tools::COMMAND_RPC_IMPORT_WALLET_REQUEST::request oreq;
   oreq.address = get_account().get_public_address_str(m_nettype);
   oreq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json("/import_wallet_request", oreq, response, rpc_timeout, "POST");
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "import_wallet_request");
  
  
   return true;
 }

Here is the call graph for this function:

◆ light_wallet_key_image_is_ours()

bool tools::wallet2::light_wallet_key_image_is_ours	(	const crypto::key_image &	key_image,
		const crypto::public_key &	tx_public_key,
		uint64_t	out_index
	)

Definition at line 9457 of file wallet2.cpp.

 {
   // Lookup key image from cache
   std::map<uint64_t, crypto::key_image> index_keyimage_map;
   std::unordered_map<crypto::public_key, std::map<uint64_t, crypto::key_image> >::const_iterator found_pub_key = m_key_image_cache.find(tx_public_key);
   if(found_pub_key != m_key_image_cache.end()) {
     // pub key found. key image for index cached?
     index_keyimage_map = found_pub_key->second;
     std::map<uint64_t,crypto::key_image>::const_iterator index_found = index_keyimage_map.find(out_index);
     if(index_found != index_keyimage_map.end())
       return key_image == index_found->second;
   }
  
   // Not in cache - calculate key image
   crypto::key_image calculated_key_image;
   cryptonote::keypair in_ephemeral;
   
   // Subaddresses aren't supported in mymonero/openmonero yet. Roll out the original scheme:
   //   compute D = a*R
   //   compute P = Hs(D || i)*G + B
   //   compute x = Hs(D || i) + b      (and check if P==x*G)
   //   compute I = x*Hp(P)
   const account_keys& ack = get_account().get_keys();
   crypto::key_derivation derivation;
   bool r = crypto::generate_key_derivation(tx_public_key, ack.m_view_secret_key, derivation);
   CHECK_AND_ASSERT_MES(r, false, "failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
  
   r = crypto::derive_public_key(derivation, out_index, ack.m_account_address.m_spend_public_key, in_ephemeral.pub);
   CHECK_AND_ASSERT_MES(r, false, "failed to derive_public_key (" << derivation << ", " << out_index << ", " << ack.m_account_address.m_spend_public_key << ")");
  
   crypto::derive_secret_key(derivation, out_index, ack.m_spend_secret_key, in_ephemeral.sec);
   crypto::public_key out_pkey_test;
   r = crypto::secret_key_to_public_key(in_ephemeral.sec, out_pkey_test);
   CHECK_AND_ASSERT_MES(r, false, "failed to secret_key_to_public_key(" << in_ephemeral.sec << ")");
   CHECK_AND_ASSERT_MES(in_ephemeral.pub == out_pkey_test, false, "derived secret key doesn't match derived public key");
  
   crypto::generate_key_image(in_ephemeral.pub, in_ephemeral.sec, calculated_key_image);
  
   index_keyimage_map.emplace(out_index, calculated_key_image);
   m_key_image_cache.emplace(tx_public_key, index_keyimage_map);
   return key_image == calculated_key_image;
 }

Here is the call graph for this function:

◆ light_wallet_login()

bool tools::wallet2::light_wallet_login ( bool & new_address )

Definition at line 9030 of file wallet2.cpp.

 {
   MDEBUG("Light wallet login request");
   m_light_wallet_connected = false;
   tools::COMMAND_RPC_LOGIN::request request;
   tools::COMMAND_RPC_LOGIN::response response;
   request.address = get_account().get_public_address_str(m_nettype);
   request.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
   // Always create account if it doesn't exist.
   request.create_account = true;
   m_daemon_rpc_mutex.lock();
   bool connected = invoke_http_json("/login", request, response, rpc_timeout, "POST");
   m_daemon_rpc_mutex.unlock();
   // MyMonero doesn't send any status message. OpenMonero does. 
   m_light_wallet_connected  = connected && (response.status.empty() || response.status == "success");
   new_address = response.new_address;
   MDEBUG("Status: " << response.status);
   MDEBUG("Reason: " << response.reason);
   MDEBUG("New wallet: " << response.new_address);
   if(m_light_wallet_connected)
   {
     // Clear old data on successful login.
     // m_transfers.clear();
     // m_payments.clear();
     // m_unconfirmed_payments.clear();
   }
   return m_light_wallet_connected;
 }

Here is the call graph for this function:

◆ light_wallet_parse_rct_str()

bool tools::wallet2::light_wallet_parse_rct_str	(	const std::string &	rct_string,
		const crypto::public_key &	tx_pub_key,
		uint64_t	internal_output_index,
		rct::key &	decrypted_mask,
		rct::key &	rct_commit,
		bool	decrypt
	)		const

Definition at line 9432 of file wallet2.cpp.

 {
   // rct string is empty if output is non RCT
   if (rct_string.empty())
     return false;
   // rct_string is a string with length 64+64+64 (<rct commit> + <encrypted mask> + <rct amount>)
   rct::key encrypted_mask;
   std::string rct_commit_str = rct_string.substr(0,64);
   std::string encrypted_mask_str = rct_string.substr(64,64);
   THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, rct_commit_str), error::wallet_internal_error, "Invalid rct commit hash: " + rct_commit_str);
   THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, encrypted_mask_str), error::wallet_internal_error, "Invalid rct mask: " + encrypted_mask_str);
   string_tools::hex_to_pod(rct_commit_str, rct_commit);
   string_tools::hex_to_pod(encrypted_mask_str, encrypted_mask);
   if (decrypt) {
     // Decrypt the mask
     crypto::key_derivation derivation;
     bool r = generate_key_derivation(tx_pub_key, get_account().get_keys().m_view_secret_key, derivation);
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
     crypto::secret_key scalar;
     crypto::derivation_to_scalar(derivation, internal_output_index, scalar);
     sc_sub(decrypted_mask.bytes,encrypted_mask.bytes,rct::hash_to_scalar(rct::sk2rct(scalar)).bytes);
   }
   return true;
 }

Here is the call graph for this function:

◆ load()

void tools::wallet2::load	(	const std::string &	wallet,
		const epee::wipeable_string &	password
	)

Definition at line 5723 of file wallet2.cpp.

 {
   clear();
   prepare_file_names(wallet_);
  
   boost::system::error_code e;
   bool exists = boost::filesystem::exists(m_keys_file, e);
   THROW_WALLET_EXCEPTION_IF(e || !exists, error::file_not_found, m_keys_file);
   lock_keys_file();
   THROW_WALLET_EXCEPTION_IF(!is_keys_file_locked(), error::wallet_internal_error, "internal error: \"" + m_keys_file + "\" is opened by another wallet program");
  
   // this temporary unlocking is necessary for Windows (otherwise the file couldn't be loaded).
   unlock_keys_file();
   if (!load_keys(m_keys_file, password))
   {
     THROW_WALLET_EXCEPTION_IF(true, error::file_read_error, m_keys_file);
   }
   LOG_PRINT_L0("Loaded wallet keys file, with public address: " << m_account.get_public_address_str(m_nettype));
   lock_keys_file();
  
   wallet_keys_unlocker unlocker(*this, m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only, password);
  
   //keys loaded ok!
   //try to load wallet file. but even if we failed, it is not big problem
   if(!boost::filesystem::exists(m_wallet_file, e) || e)
   {
     LOG_PRINT_L0("file not found: " << m_wallet_file << ", starting with empty blockchain");
     m_account_public_address = m_account.get_keys().m_account_address;
   }
   else
   {
     wallet2::cache_file_data cache_file_data;
     std::string buf;
     bool r = epee::file_io_utils::load_file_to_string(m_wallet_file, buf, std::numeric_limits<size_t>::max());
     THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, m_wallet_file);
  
     // try to read it as an encrypted cache
     try
     {
       LOG_PRINT_L1("Trying to decrypt cache data");
  
       r = ::serialization::parse_binary(buf, cache_file_data);
       THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + m_wallet_file + '\"');
       std::string cache_data;
       cache_data.resize(cache_file_data.cache_data.size());
       crypto::chacha20(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), m_cache_key, cache_file_data.iv, &cache_data[0]);
  
       try {
         std::stringstream iss;
         iss << cache_data;
         boost::archive::portable_binary_iarchive ar(iss);
         ar >> *this;
       }
       catch(...)
       {
         // try with previous scheme: direct from keys
         crypto::chacha_key key;
         generate_chacha_key_from_secret_keys(key);
         crypto::chacha20(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), key, cache_file_data.iv, &cache_data[0]);
         try {
           std::stringstream iss;
           iss << cache_data;
           boost::archive::portable_binary_iarchive ar(iss);
           ar >> *this;
         }
         catch (...)
         {
           crypto::chacha8(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), key, cache_file_data.iv, &cache_data[0]);
           try
           {
             std::stringstream iss;
             iss << cache_data;
             boost::archive::portable_binary_iarchive ar(iss);
             ar >> *this;
           }
           catch (...)
           {
             LOG_PRINT_L0("Failed to open portable binary, trying unportable");
             boost::filesystem::copy_file(m_wallet_file, m_wallet_file + ".unportable", boost::filesystem::copy_option::overwrite_if_exists);
             std::stringstream iss;
             iss.str("");
             iss << cache_data;
             boost::archive::binary_iarchive ar(iss);
             ar >> *this;
           }
         }
       }
     }
     catch (...)
     {
       LOG_PRINT_L1("Failed to load encrypted cache, trying unencrypted");
       try {
         std::stringstream iss;
         iss << buf;
         boost::archive::portable_binary_iarchive ar(iss);
         ar >> *this;
       }
       catch (...)
       {
         LOG_PRINT_L0("Failed to open portable binary, trying unportable");
         boost::filesystem::copy_file(m_wallet_file, m_wallet_file + ".unportable", boost::filesystem::copy_option::overwrite_if_exists);
         std::stringstream iss;
         iss.str("");
         iss << buf;
         boost::archive::binary_iarchive ar(iss);
         ar >> *this;
       }
     }
     THROW_WALLET_EXCEPTION_IF(
       m_account_public_address.m_spend_public_key != m_account.get_keys().m_account_address.m_spend_public_key ||
       m_account_public_address.m_view_public_key  != m_account.get_keys().m_account_address.m_view_public_key,
       error::wallet_files_doesnt_correspond, m_keys_file, m_wallet_file);
   }
  
   cryptonote::block genesis;
   generate_genesis(genesis);
   crypto::hash genesis_hash = get_block_hash(genesis);
  
   if (m_blockchain.empty())
   {
     m_blockchain.push_back(genesis_hash);
     m_last_block_reward = cryptonote::get_outs_etn_amount(genesis.miner_tx);
   }
   else
   {
     check_genesis(genesis_hash);
   }
  
   trim_hashchain();
  
   if (get_num_subaddress_accounts() == 0)
     add_subaddress_account(tr("Primary account"));
  
   try
   {
     find_and_save_rings(false);
   }
   catch (const std::exception &e)
   {
     MERROR("Failed to save rings, will try again next time");
   }
   
   try
   {
     m_message_store.read_from_file(get_multisig_wallet_state(), m_mms_file);
   }
   catch (const std::exception &e)
   {
     MERROR("Failed to initialize MMS, it will be unusable");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_multisig_tx()

bool tools::wallet2::load_multisig_tx	(	cryptonote::blobdata	blob,
		multisig_tx_set &	exported_txs,
		std::function< bool(const multisig_tx_set &)>	accept_func = `NULL`
	)

Definition at line 7348 of file wallet2.cpp.

 {
   if(!parse_multisig_tx_from_str(s, exported_txs))
   {
     LOG_PRINT_L0("Failed to parse multisig transaction from string");
     return false;
   }
  
   LOG_PRINT_L1("Loaded multisig tx unsigned data from binary: " << exported_txs.m_ptx.size() << " transactions");
   for (auto &ptx: exported_txs.m_ptx) LOG_PRINT_L0(cryptonote::obj_to_json_str(ptx.tx));
  
   if (accept_func && !accept_func(exported_txs))
   {
     LOG_PRINT_L1("Transactions rejected by callback");
     return false;
   }
  
   const bool is_signed = exported_txs.m_signers.size() >= m_multisig_threshold;
   if (is_signed)
   {
     for (const auto &ptx: exported_txs.m_ptx)
     {
       const crypto::hash txid = get_transaction_hash(ptx.tx);
       if (store_tx_info())
       {
         m_tx_keys.insert(std::make_pair(txid, ptx.tx_key));
         m_additional_tx_keys.insert(std::make_pair(txid, ptx.additional_tx_keys));
       }
     }
   }
  
   return true;
 }

Here is the call graph for this function:

◆ load_multisig_tx_from_file()

bool tools::wallet2::load_multisig_tx_from_file	(	const std::string &	filename,
		multisig_tx_set &	exported_txs,
		std::function< bool(const multisig_tx_set &)>	accept_func = `NULL`
	)

Definition at line 7382 of file wallet2.cpp.

 {
   std::string s;
   boost::system::error_code errcode;
  
   if (!boost::filesystem::exists(filename, errcode))
   {
     LOG_PRINT_L0("File " << filename << " does not exist: " << errcode);
     return false;
   }
   if (!epee::file_io_utils::load_file_to_string(filename.c_str(), s))
   {
     LOG_PRINT_L0("Failed to load from " << filename);
     return false;
   }
  
   if (!load_multisig_tx(s, exported_txs, accept_func))
   {
     LOG_PRINT_L0("Failed to parse multisig tx data from " << filename);
     return false;
   }
   return true;
 }

Here is the call graph for this function:

◆ load_tx()

bool tools::wallet2::load_tx	(	const std::string &	signed_filename,
		std::vector< tools::wallet2::pending_tx > &	ptx,
		std::function< bool(const signed_tx_set &)>	accept_func = `NULL`
	)

Definition at line 7120 of file wallet2.cpp.

 {
   std::string s;
   boost::system::error_code errcode;
   signed_tx_set signed_txs;
  
   if (!boost::filesystem::exists(signed_filename, errcode))
   {
     LOG_PRINT_L0("File " << signed_filename << " does not exist: " << errcode);
     return false;
   }
  
   if (!epee::file_io_utils::load_file_to_string(signed_filename.c_str(), s))
   {
     LOG_PRINT_L0("Failed to load from " << signed_filename);
     return false;
   }
  
   return parse_tx_from_str(s, ptx, accept_func);
 }

Here is the call graph for this function:

◆ load_unsigned_tx()

bool tools::wallet2::load_unsigned_tx	(	const std::string &	unsigned_filename,
		unsigned_tx_set &	exported_txs
	)		const

Definition at line 6813 of file wallet2.cpp.

 {
   std::string s;
   boost::system::error_code errcode;
  
   if (!boost::filesystem::exists(unsigned_filename, errcode))
   {
     LOG_PRINT_L0("File " << unsigned_filename << " does not exist: " << errcode);
     return false;
   }
   if (!epee::file_io_utils::load_file_to_string(unsigned_filename.c_str(), s))
   {
     LOG_PRINT_L0("Failed to load from " << unsigned_filename);
     return false;
   }
  
   return parse_unsigned_tx_from_str(s, exported_txs);
 }

Here is the call graph for this function:

◆ lock_keys_file()

bool tools::wallet2::lock_keys_file ( )

Definition at line 8004 of file wallet2.cpp.

 {
   if (m_keys_file_locker)
   {
     MDEBUG(m_keys_file << " is already locked.");
     return false;
   }
   m_keys_file_locker.reset(new tools::file_locker(m_keys_file));
   return true;
 }

◆ make_dummy()

std::unique_ptr< wallet2 > tools::wallet2::make_dummy	(	const boost::program_options::variables_map &	vm,
		bool	unattended,
		const std::function< boost::optional< password_container >(const char *, bool)> &	password_prompter
	)

static

Just parses variables.

Definition at line 1260 of file wallet2.cpp.

 {
   const options opts{};
   return make_basic(vm, unattended, opts, password_prompter);
 }

◆ make_from_file()

std::pair< std::unique_ptr< wallet2 >, password_container > tools::wallet2::make_from_file	(	const boost::program_options::variables_map &	vm,
		bool	unattended,
		const std::string &	wallet_file,
		const std::function< boost::optional< password_container >(const char *, bool)> &	password_prompter
	)

static

Uses stdin and stdout. Returns a wallet2 and password for wallet_file if no errors.

Definition at line 1232 of file wallet2.cpp.

 {
   const options opts{};
   auto pwd = get_password(vm, opts, password_prompter, false);
   if (!pwd)
   {
     return {nullptr, password_container{}};
   }
   auto wallet = make_basic(vm, unattended, opts, password_prompter);
   if (wallet && !wallet_file.empty())
   {
     wallet->load(wallet_file, pwd->password());
   }
   return {std::move(wallet), std::move(*pwd)};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_from_json()

std::pair< std::unique_ptr< wallet2 >, tools::password_container > tools::wallet2::make_from_json	(	const boost::program_options::variables_map &	vm,
		bool	unattended,
		const std::string &	json_file,
		const std::function< boost::optional< password_container >(const char *, bool)> &	password_prompter
	)

static

Uses stdin and stdout. Returns a wallet2 if no errors.

Definition at line 1226 of file wallet2.cpp.

 {
   const options opts{};
   return generate_from_json(json_file, vm, unattended, opts, password_prompter);
 }

Here is the caller graph for this function:

◆ make_multisig() [1/2]

std::string tools::wallet2::make_multisig	(	const epee::wipeable_string &	password,
		const std::vector< crypto::secret_key > &	view_keys,
		const std::vector< crypto::public_key > &	spend_keys,
		uint32_t	threshold
	)

Creates a multisig wallet.

Returns: empty if done, non empty if we need to send another string to other participants

Definition at line 5035 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(!view_keys.empty(), "empty view keys");
   CHECK_AND_ASSERT_THROW_MES(view_keys.size() == spend_keys.size(), "Mismatched view/spend key sizes");
   CHECK_AND_ASSERT_THROW_MES(threshold > 1 && threshold <= spend_keys.size() + 1, "Invalid threshold");
  
   std::string extra_multisig_info;
   std::vector<crypto::secret_key> multisig_keys;
   rct::key spend_pkey = rct::identity();
   rct::key spend_skey;
   std::vector<crypto::public_key> multisig_signers;
  
   // decrypt keys
   epee::misc_utils::auto_scope_leave_caller keys_reencryptor;
   if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
   {
     crypto::chacha_key chacha_key;
     crypto::generate_chacha_key(password.data(), password.size(), chacha_key, m_kdf_rounds);
     m_account.encrypt_viewkey(chacha_key);
     m_account.decrypt_keys(chacha_key);
     keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this, chacha_key]() { m_account.encrypt_keys(chacha_key); m_account.decrypt_viewkey(chacha_key); });
   }
  
   // In common multisig scheme there are 4 types of key exchange rounds:
   // 1. First round is exchange of view secret keys and public spend keys.
   // 2. Middle round is exchange of derivations: Ki = b * Mj, where b - spend secret key,
   //    M - public multisig key (in first round it equals to public spend key), K - new public multisig key.
   // 3. Secret spend establishment round sets your secret multisig keys as follows: kl = H(Ml), where M - is *your* public multisig key,
   //    k - secret multisig key used to sign transactions. k and M are sets of keys, of course.
   //    And secret spend key as the sum of all participant's secret multisig keys
   // 4. Last round establishes multisig wallet's public spend key. Participants exchange their public multisig keys
   //    and calculate common spend public key as sum of all unique participants' public multisig keys.
   // Note that N/N scheme has only first round. N-1/N has 2 rounds: first and last. Common M/N has all 4 rounds.
  
   // IMPORTANT: wallet's public spend key is not equal to secret_spend_key * G!
   // Wallet's public spend key is the sum of unique public multisig keys of all participants.
   // secret_spend_key * G = public signer key
  
   if (threshold == spend_keys.size() + 1)
   {
     // In N / N case we only need to do one round and calculate secret multisig keys and new secret spend key
     MINFO("Creating spend key...");
  
     // Calculates all multisig keys and spend key
     cryptonote::generate_multisig_N_N(get_account().get_keys(), spend_keys, multisig_keys, spend_skey, spend_pkey);
  
     // Our signer key is b * G, where b is secret spend key.
     multisig_signers = spend_keys;
     multisig_signers.push_back(get_multisig_signer_public_key(get_account().get_keys().m_spend_secret_key));
   }
   else
   {
     // We just got public spend keys of all participants and deriving multisig keys (set of Mi = b * Bi).
     // note that derivations are public keys as DH exchange suppose it to be
     auto derivations = cryptonote::generate_multisig_derivations(get_account().get_keys(), spend_keys);
  
     spend_pkey = rct::identity();
     multisig_signers = std::vector<crypto::public_key>(spend_keys.size() + 1, crypto::null_pkey);
  
     if (threshold == spend_keys.size())
     {
       // N - 1 / N case
  
       // We need an extra step, so we package all the composite public keys
       // we know about, and make a signed string out of them
       MINFO("Creating spend key...");
  
       // Calculating set of our secret multisig keys as follows: mi = H(Mi),
       // where mi - secret multisig key, Mi - others' participants public multisig key
       multisig_keys = cryptonote::calculate_multisig_keys(derivations);
  
       // calculating current participant's spend secret key as sum of all secret multisig keys for current participant.
       // IMPORTANT: participant's secret spend key is not an entire wallet's secret spend!
       //            Entire wallet's secret spend is sum of all unique secret multisig keys
       //            among all of participants and is not held by anyone!
       spend_skey = rct::sk2rct(cryptonote::calculate_multisig_signer_key(multisig_keys));
  
       // Preparing data for the last round to calculate common public spend key. The data contains public multisig keys.
       extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, secret_keys_to_public_keys(multisig_keys), rct::rct2sk(spend_skey));
     }
     else
     {
       // M / N case
       MINFO("Preparing keys for next exchange round...");
  
       // Preparing data for middle round - packing new public multisig keys to exchage with others.
       extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, derivations, m_account.get_keys().m_spend_secret_key);
       spend_skey = rct::sk2rct(m_account.get_keys().m_spend_secret_key);
  
       // Need to store middle keys to be able to proceed in case of wallet shutdown.
       m_multisig_derivations = derivations;
     }
   }
   
   if (!m_original_keys_available)
   {
     // Save the original i.e. non-multisig keys so the MMS can continue to use them to encrypt and decrypt messages
     // (making a wallet multisig overwrites those keys, see account_base::make_multisig)
     m_original_address = m_account.get_keys().m_account_address;
     m_original_view_secret_key = m_account.get_keys().m_view_secret_key;
     m_original_keys_available = true;
   }
  
   clear();
   MINFO("Creating view key...");
   crypto::secret_key view_skey = cryptonote::generate_multisig_view_secret_key(get_account().get_keys().m_view_secret_key, view_keys);
  
   MINFO("Creating multisig address...");
   CHECK_AND_ASSERT_THROW_MES(m_account.make_multisig(view_skey, rct::rct2sk(spend_skey), rct::rct2pk(spend_pkey), multisig_keys),
       "Failed to create multisig wallet due to bad keys");
   memwipe(&spend_skey, sizeof(rct::key));
  
   init_type(hw::device::device_type::SOFTWARE);
   m_original_keys_available = true;
   m_multisig = true;
   m_multisig_threshold = threshold;
   m_multisig_signers = multisig_signers;
   ++m_multisig_rounds_passed;
  
   // re-encrypt keys
   keys_reencryptor = epee::misc_utils::auto_scope_leave_caller();
  
   create_keys_file(m_wallet_file, false, password, boost::filesystem::exists(m_wallet_file + ".address.txt"));
  
   setup_new_blockchain();
  
   if (!m_wallet_file.empty())
     store();
  
   return extra_multisig_info;
 }

Here is the call graph for this function:

◆ make_multisig() [2/2]

std::string tools::wallet2::make_multisig	(	const epee::wipeable_string &	password,
		const std::vector< std::string > &	info,
		uint32_t	threshold
	)

Creates a multisig wallet.

Returns: empty if done, non empty if we need to send another string to other participants

Definition at line 5356 of file wallet2.cpp.

 {
   std::vector<crypto::secret_key> secret_keys(info.size());
   std::vector<crypto::public_key> public_keys(info.size());
   unpack_multisig_info(info, public_keys, secret_keys);
   return make_multisig(password, secret_keys, public_keys, threshold);
 }

◆ make_multisig_tx_set()

wallet2::multisig_tx_set tools::wallet2::make_multisig_tx_set ( const std::vector< pending_tx > & ptx_vector ) const

Definition at line 7276 of file wallet2.cpp.

 {
   multisig_tx_set txs;
   txs.m_ptx = ptx_vector;
  
   for (const auto &msk: get_account().get_multisig_keys())
   {
     crypto::public_key pkey = get_multisig_signing_public_key(msk);
     for (auto &ptx: txs.m_ptx) for (auto &sig: ptx.multisig_sigs) sig.signing_keys.insert(pkey);
   }
  
   txs.m_signers.insert(get_multisig_signer_public_key());
   return txs;
 }

◆ make_new()

std::pair< std::unique_ptr< wallet2 >, password_container > tools::wallet2::make_new	(	const boost::program_options::variables_map &	vm,
		bool	unattended,
		const std::function< boost::optional< password_container >(const char *, bool)> &	password_prompter
	)

static

Uses stdin and stdout. Returns a wallet2 and password for wallet with no file if no errors.

Definition at line 1249 of file wallet2.cpp.

 {
   const options opts{};
   auto pwd = get_password(vm, opts, password_prompter, true);
   if (!pwd)
   {
     return {nullptr, password_container{}};
   }
   return {make_basic(vm, unattended, opts, password_prompter), std::move(*pwd)};
 }

Here is the call graph for this function:

◆ make_uri()

std::string tools::wallet2::make_uri	(	const std::string &	address,
		const std::string &	payment_id,
		uint64_t	amount,
		const std::string &	tx_description,
		const std::string &	recipient_name,
		std::string &	error
	)		const

Definition at line 13035 of file wallet2.cpp.

 {
   cryptonote::address_parse_info info;
   if(!get_account_address_from_str(info, nettype(), address))
   {
     error = std::string("wrong address: ") + address;
     return std::string();
   }
  
   // we want only one payment id
   if (info.has_payment_id && !payment_id.empty())
   {
     error = "A single payment id is allowed";
     return std::string();
   }
  
   if (!payment_id.empty())
   {
     crypto::hash pid32;
     crypto::hash8 pid8;
     if (!wallet2::parse_long_payment_id(payment_id, pid32) && !parse_short_payment_id(payment_id, pid8))
     {
       error = "Invalid payment id";
       return std::string();
     }
   }
  
   std::string uri = "electroneum:" + address;
   unsigned int n_fields = 0;
  
   if (!payment_id.empty())
   {
     uri += (n_fields++ ? "&" : "?") + std::string("tx_payment_id=") + payment_id;
   }
  
   if (amount > 0)
   {
     // URI encoded amount is in decimal units, not atomic units
     uri += (n_fields++ ? "&" : "?") + std::string("tx_amount=") + cryptonote::print_etn(amount);
   }
  
   if (!recipient_name.empty())
   {
     uri += (n_fields++ ? "&" : "?") + std::string("recipient_name=") + epee::net_utils::conver_to_url_format(recipient_name);
   }
  
   if (!tx_description.empty())
   {
     uri += (n_fields++ ? "&" : "?") + std::string("tx_description=") + epee::net_utils::conver_to_url_format(tx_description);
   }
  
   return uri;
 }

Here is the call graph for this function:

◆ merge_destinations() [1/2]

bool tools::wallet2::merge_destinations ( ) const

inline

Definition at line 1078 of file wallet2.h.

1078 { return m_merge_destinations; }

◆ merge_destinations() [2/2]

void tools::wallet2::merge_destinations ( bool merge )

inline

Definition at line 1077 of file wallet2.h.

1077 { m_merge_destinations = merge; }

◆ multisig()

bool tools::wallet2::multisig	(	bool *	ready = `NULL`,
		uint32_t *	threshold = `NULL`,
		uint32_t *	total = `NULL`
	)		const

Definition at line 5524 of file wallet2.cpp.

 {
   if (!m_multisig)
     return false;
   if (threshold)
     *threshold = m_multisig_threshold;
   if (total)
     *total = m_multisig_signers.size();
   if (ready)
     *ready = !(get_account().get_keys().m_account_address.m_spend_public_key == rct::rct2pk(rct::identity()));
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nettype()

cryptonote::network_type tools::wallet2::nettype ( ) const

inline

Definition at line 818 of file wallet2.h.

818 { return m_nettype; }

Here is the caller graph for this function:

◆ parse_long_payment_id()

bool tools::wallet2::parse_long_payment_id	(	const std::string &	payment_id_str,
		crypto::hash &	payment_id
	)

static

Definition at line 5602 of file wallet2.cpp.

 {
   cryptonote::blobdata payment_id_data;
   if(!epee::string_tools::parse_hexstr_to_binbuff(payment_id_str, payment_id_data))
     return false;
  
   if(sizeof(crypto::hash) != payment_id_data.size())
     return false;
  
   payment_id = *reinterpret_cast<const crypto::hash*>(payment_id_data.data());
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_multisig_tx_from_str()

bool tools::wallet2::parse_multisig_tx_from_str	(	std::string	multisig_tx_st,
		multisig_tx_set &	exported_txs
	)		const

Definition at line 7304 of file wallet2.cpp.

 {
   const size_t magiclen = strlen(MULTISIG_UNSIGNED_TX_PREFIX);
   if (strncmp(multisig_tx_st.c_str(), MULTISIG_UNSIGNED_TX_PREFIX, magiclen))
   {
     LOG_PRINT_L0("Bad magic from multisig tx data");
     return false;
   }
   try
   {
     multisig_tx_st = decrypt_with_view_secret_key(std::string(multisig_tx_st, magiclen));
   }
   catch (const std::exception &e)
   {
     LOG_PRINT_L0("Failed to decrypt multisig tx data: " << e.what());
     return false;
   }
   try
   {
     std::istringstream iss(multisig_tx_st);
     boost::archive::portable_binary_iarchive ar(iss);
     ar >> exported_txs;
   }
   catch (...)
   {
     LOG_PRINT_L0("Failed to parse multisig tx data");
     return false;
   }
  
   // sanity checks
   for (const auto &ptx: exported_txs.m_ptx)
   {
     CHECK_AND_ASSERT_MES(ptx.selected_transfers.size() == ptx.tx.vin.size(), false, "Mismatched selected_transfers/vin sizes");
     for (size_t idx: ptx.selected_transfers)
       CHECK_AND_ASSERT_MES(idx < m_transfers.size(), false, "Transfer index out of range");
     CHECK_AND_ASSERT_MES(ptx.construction_data.selected_transfers.size() == ptx.tx.vin.size(), false, "Mismatched cd selected_transfers/vin sizes");
     for (size_t idx: ptx.construction_data.selected_transfers)
       CHECK_AND_ASSERT_MES(idx < m_transfers.size(), false, "Transfer index out of range");
     CHECK_AND_ASSERT_MES(ptx.construction_data.sources.size() == ptx.tx.vin.size(), false, "Mismatched sources/vin sizes");
   }
  
   return true;
 }

◆ parse_payment_id()

bool tools::wallet2::parse_payment_id	(	const std::string &	payment_id_str,
		crypto::hash &	payment_id
	)

static

Definition at line 5628 of file wallet2.cpp.

 {
   if (parse_long_payment_id(payment_id_str, payment_id))
     return true;
   crypto::hash8 payment_id8;
   if (parse_short_payment_id(payment_id_str, payment_id8))
   {
     memcpy(payment_id.data, payment_id8.data, 8);
     memset(payment_id.data + 8, 0, 24);
     return true;
   }
   return false;
 }

Here is the call graph for this function:

◆ parse_short_payment_id()

bool tools::wallet2::parse_short_payment_id	(	const std::string &	payment_id_str,
		crypto::hash8 &	payment_id
	)

static

Definition at line 5615 of file wallet2.cpp.

 {
   cryptonote::blobdata payment_id_data;
   if(!epee::string_tools::parse_hexstr_to_binbuff(payment_id_str, payment_id_data))
     return false;
  
   if(sizeof(crypto::hash8) != payment_id_data.size())
     return false;
  
   payment_id = *reinterpret_cast<const crypto::hash8*>(payment_id_data.data());
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_tx_from_str()

bool tools::wallet2::parse_tx_from_str	(	const std::string &	signed_tx_st,
		std::vector< tools::wallet2::pending_tx > &	ptx,
		std::function< bool(const signed_tx_set &)>	accept_func
	)

Definition at line 7141 of file wallet2.cpp.

 {
   std::string s = signed_tx_st;
   boost::system::error_code errcode;
   signed_tx_set signed_txs;
  
   const size_t magiclen = strlen(SIGNED_TX_PREFIX) - 1;
   if (strncmp(s.c_str(), SIGNED_TX_PREFIX, magiclen))
   {
     LOG_PRINT_L0("Bad magic from signed transaction");
     return false;
   }
   s = s.substr(magiclen);
   const char version = s[0];
   s = s.substr(1);
   if (version == '\003')
   {
     try
     {
       std::istringstream iss(s);
       boost::archive::portable_binary_iarchive ar(iss);
       ar >> signed_txs;
     }
     catch (const std::exception &e)
     {
       LOG_PRINT_L0("Failed to parse data from signed transaction: " << e.what());
       return false;
     }
     catch(...)
     {
     LOG_PRINT_L0("Failed to parse data from signed transaction");
     return false;
     }
   }
   else if (version == '\004')
   {
     try
     {
       s = decrypt_with_view_secret_key(s);
       try
       {
         std::istringstream iss(s);
         boost::archive::portable_binary_iarchive ar(iss);
         ar >> signed_txs;
       }
       catch (const std::exception &e)
       {
         LOG_PRINT_L0("Failed to parse decrypted data from signed transaction: " << e.what());
         return false;
       }
     }
     catch (const std::exception &e)
     {
       LOG_PRINT_L0("Failed to decrypt signed transaction: " << e.what());
       return false;
     }
     catch(...)
     {
     LOG_PRINT_L0("Failed to decrypt signed transaction");
     return false;
     }
   }
   else
   {
     LOG_PRINT_L0("Unsupported version in signed transaction");
     return false;
   }
   LOG_PRINT_L0("Loaded signed tx data from binary: " << signed_txs.ptx.size() << " transactions");
   for (auto &c_ptx: signed_txs.ptx) LOG_PRINT_L0(cryptonote::obj_to_json_str(c_ptx.tx));
  
   if (accept_func && !accept_func(signed_txs))
   {
     LOG_PRINT_L1("Transactions rejected by callback");
     return false;
   }
  
   // import key images
   bool r = import_key_images(signed_txs.key_images);
   if (!r) return false;
  
   // remember key images for this tx, for when we get those txes from the blockchain
   for (const auto &e: signed_txs.tx_key_images)
     m_cold_key_images.insert(e);
  
   ptx = signed_txs.ptx;
  
   return true;
 }

Here is the call graph for this function:

◆ parse_unsigned_tx_from_str()

bool tools::wallet2::parse_unsigned_tx_from_str	(	const std::string &	unsigned_tx_st,
		unsigned_tx_set &	exported_txs
	)		const

Definition at line 6832 of file wallet2.cpp.

 {
   std::string s = unsigned_tx_st;
   const size_t magiclen = strlen(UNSIGNED_TX_PREFIX) - 1;
   if (strncmp(s.c_str(), UNSIGNED_TX_PREFIX, magiclen))
   {
     LOG_PRINT_L0("Bad magic from unsigned tx");
     return false;
   }
   s = s.substr(magiclen);
   const char version = s[0];
   s = s.substr(1);
   if (version == '\003')
   {
     try
     {
       std::istringstream iss(s);
       boost::archive::portable_binary_iarchive ar(iss);
       ar >> exported_txs;
     }
     catch (const std::exception &e)
     {
       LOG_PRINT_L0("Failed to parse data from unsigned tx: " << e.what());
       return false;
     }
     catch (...)
     {
     LOG_PRINT_L0("Failed to parse data from unsigned tx");
     return false;
     }
   }
   else if (version == '\004')
   {
     try
     {
       s = decrypt_with_view_secret_key(s);
       try
       {
         std::istringstream iss(s);
         boost::archive::portable_binary_iarchive ar(iss);
         ar >> exported_txs;
       }
       catch (const std::exception &e)
       {
         LOG_PRINT_L0("Failed to parse decrypted data from unsigned tx: " << e.what());
         return false;
       }
     }
     catch (const std::exception &e)
     {
       LOG_PRINT_L0("Failed to decrypt unsigned tx: " << e.what());
       return false;
     }
     catch(...)
     {
     LOG_PRINT_L0("Failed to parse decrypted data from unsigned tx");
     return false;
     }
   }
   else
   {
     LOG_PRINT_L0("Unsupported version in unsigned tx");
     return false;
   }
   LOG_PRINT_L1("Loaded tx unsigned data from binary: " << exported_txs.txes.size() << " transactions");
  
   return true;
 }

◆ parse_uri()

bool tools::wallet2::parse_uri	(	const std::string &	uri,
		std::string &	address,
		std::string &	payment_id,
		uint64_t &	amount,
		std::string &	tx_description,
		std::string &	recipient_name,
		std::vector< std::string > &	unknown_parameters,
		std::string &	error
	)

Definition at line 13089 of file wallet2.cpp.

 {
   if (uri.substr(0, 12) != "electroneum:")
   {
     error = std::string("URI has wrong scheme (expected \"electroneum:\"): ") + uri;
     return false;
   }
  
   std::string remainder = uri.substr(12);
   const char *ptr = strchr(remainder.c_str(), '?');
   address = ptr ? remainder.substr(0, ptr-remainder.c_str()) : remainder;
  
   cryptonote::address_parse_info info;
   if(!get_account_address_from_str(info, nettype(), address))
   {
     error = std::string("URI has wrong address: ") + address;
     return false;
   }
   if (!strchr(remainder.c_str(), '?'))
     return true;
  
   std::vector<std::string> arguments;
   std::string body = remainder.substr(address.size() + 1);
   if (body.empty())
     return true;
   boost::split(arguments, body, boost::is_any_of("&"));
   std::set<std::string> have_arg;
   for (const auto &arg: arguments)
   {
     std::vector<std::string> kv;
     boost::split(kv, arg, boost::is_any_of("="));
     if (kv.size() != 2)
     {
       error = std::string("URI has wrong parameter: ") + arg;
       return false;
     }
     if (have_arg.find(kv[0]) != have_arg.end())
     {
       error = std::string("URI has more than one instance of " + kv[0]);
       return false;
     }
     have_arg.insert(kv[0]);
  
     if (kv[0] == "tx_amount")
     {
       amount = 0;
       if (!cryptonote::parse_amount(amount, kv[1]))
       {
         error = std::string("URI has invalid amount: ") + kv[1];
         return false;
       }
     }
     else if (kv[0] == "tx_payment_id")
     {
       if (info.has_payment_id)
       {
         error = "Separate payment id given with an integrated address";
         return false;
       }
       crypto::hash hash;
       crypto::hash8 hash8;
       if (!wallet2::parse_long_payment_id(kv[1], hash) && !wallet2::parse_short_payment_id(kv[1], hash8))
       {
         error = "Invalid payment id: " + kv[1];
         return false;
       }
       payment_id = kv[1];
     }
     else if (kv[0] == "recipient_name")
     {
       recipient_name = epee::net_utils::convert_from_url_format(kv[1]);
     }
     else if (kv[0] == "tx_description")
     {
       tx_description = epee::net_utils::convert_from_url_format(kv[1]);
     }
     else
     {
       unknown_parameters.push_back(arg);
     }
   }
   return true;
 }

Here is the call graph for this function:

◆ path()

std::string tools::wallet2::path ( ) const

Definition at line 5917 of file wallet2.cpp.

 {
   return m_wallet_file;
 }

◆ pop_best_value()

size_t tools::wallet2::pop_best_value	(	std::vector< size_t > &	unused_dust_indices,
		const std::vector< size_t > &	selected_transfers,
		bool	smallest = `false`
	)		const

Definition at line 6539 of file wallet2.cpp.

 {
   return pop_best_value_from(m_transfers, unused_indices, selected_transfers, smallest);
 }

◆ pop_best_value_from()

size_t tools::wallet2::pop_best_value_from	(	const transfer_container &	transfers,
		std::vector< size_t > &	unused_dust_indices,
		const std::vector< size_t > &	selected_transfers,
		bool	smallest = `false`
	)		const

Definition at line 6490 of file wallet2.cpp.

 {
   std::vector<size_t> candidates;
   float best_relatedness = 1.0f;
   for (size_t n = 0; n < unused_indices.size(); ++n)
   {
     const transfer_details &candidate = transfers[unused_indices[n]];
     float relatedness = 0.0f;
     for (std::vector<size_t>::const_iterator i = selected_transfers.begin(); i != selected_transfers.end(); ++i)
     {
       float r = get_output_relatedness(candidate, transfers[*i]);
       if (r > relatedness)
       {
         relatedness = r;
         if (relatedness == 1.0f)
           break;
       }
     }
  
     if (relatedness < best_relatedness)
     {
       best_relatedness = relatedness;
       candidates.clear();
     }
  
     if (relatedness == best_relatedness)
       candidates.push_back(n);
   }
  
   // we have all the least related outputs in candidates, so we can pick either
   // the smallest, or a random one, depending on request
   size_t idx;
   if (smallest)
   {
     idx = 0;
     for (size_t n = 0; n < candidates.size(); ++n)
     {
       const transfer_details &td = transfers[unused_indices[candidates[n]]];
       if (td.amount() < transfers[unused_indices[candidates[idx]]].amount())
         idx = n;
     }
   }
   else
   {
     idx = crypto::rand_idx(candidates.size());
   }
   return pop_index (unused_indices, candidates[idx]);
 }

Here is the call graph for this function:

◆ print_ring_members() [1/2]

bool tools::wallet2::print_ring_members ( ) const

inline

Definition at line 1059 of file wallet2.h.

1059 { return m_print_ring_members; }

◆ print_ring_members() [2/2]

void tools::wallet2::print_ring_members ( bool value )

inline

Definition at line 1060 of file wallet2.h.

1060 { m_print_ring_members = value; }

◆ public_transactions_required()

bool tools::wallet2::public_transactions_required ( ) const

inline

Definition at line 892 of file wallet2.h.

892 { return nettype() == cryptonote::network_type::MAINNET ? get_blockchain_current_height() >= (1175315 - CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS) : get_blockchain_current_height() >= (1165235 - CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS);} // prepare v2 tx if the block height is one before the fork block (which contains v2+ tx only)

Here is the call graph for this function:

◆ query_device()

bool tools::wallet2::query_device	(	hw::device::device_type &	device_type,
		const std::string &	keys_file_name,
		const epee::wipeable_string &	password,
		uint64_t	kdf_rounds = `1`
	)

static

determine the key storage for the specified wallet file

Parameters

device_type	(OUT) wallet backend as enumerated in hw::device::device_type
keys_file_name	Keys file to verify password for
password	Password to verify

Returns: true if password correct, else false

for verification only - determines key storage hardware

Definition at line 4697 of file wallet2.cpp.

 {
   rapidjson::Document json;
   wallet2::keys_file_data keys_file_data;
   std::string buf;
   bool r = epee::file_io_utils::load_file_to_string(keys_file_name, buf);
   THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, keys_file_name);
  
   // Decrypt the contents
   r = ::serialization::parse_binary(buf, keys_file_data);
   THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + keys_file_name + '\"');
   crypto::chacha_key key;
   crypto::generate_chacha_key(password.data(), password.size(), key, kdf_rounds);
   std::string account_data;
   account_data.resize(keys_file_data.account_data.size());
   crypto::chacha20(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
   if (json.Parse(account_data.c_str()).HasParseError() || !json.IsObject())
     crypto::chacha8(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
  
   device_type = hw::device::device_type::SOFTWARE;
   // The contents should be JSON if the wallet follows the new format.
   if (json.Parse(account_data.c_str()).HasParseError())
   {
     // old format before JSON wallet key file format
   }
   else
   {
     account_data = std::string(json["key_data"].GetString(), json["key_data"].GetString() +
       json["key_data"].GetStringLength());
  
     if (json.HasMember("key_on_device"))
     {
       GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, key_on_device, int, Int, false, hw::device::device_type::SOFTWARE);
       device_type = static_cast<hw::device::device_type>(field_key_on_device);
     }
   }
  
   cryptonote::account_base account_data_check;
  
   r = epee::serialization::load_t_from_binary(account_data_check, account_data);
   if (!r) return false;
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reconnect_device()

bool tools::wallet2::reconnect_device ( )

Definition at line 1389 of file wallet2.cpp.

 {
   bool r = true;
   hw::device &hwdev = lookup_device(m_device_name);
   hwdev.set_name(m_device_name);
   hwdev.set_network_type(m_nettype);
   hwdev.set_derivation_path(m_device_derivation_path);
   hwdev.set_callback(get_device_callback());
   r = hwdev.init();
   if (!r){
     MERROR("Could not init device");
     return false;
   }
  
   r = hwdev.connect();
   if (!r){
     MERROR("Could not connect to the device");
     return false;
   }
  
   m_account.set_device(hwdev);
   return true;
 }

Here is the call graph for this function:

◆ refresh() [1/4]

void tools::wallet2::refresh ( bool trusted_daemon )

Definition at line 3043 of file wallet2.cpp.

 {
   uint64_t blocks_fetched = 0;
   refresh(trusted_daemon, 0, blocks_fetched);
 }

Here is the caller graph for this function:

◆ refresh() [2/4]

bool tools::wallet2::refresh	(	bool	trusted_daemon,
		uint64_t &	blocks_fetched,
		bool &	received_etn,
		bool &	ok
	)

Definition at line 3741 of file wallet2.cpp.

 {
   try
   {
     refresh(trusted_daemon, 0, blocks_fetched, received_etn);
     ok = true;
   }
   catch (...)
   {
     ok = false;
   }
   return ok;
 }

◆ refresh() [3/4]

void tools::wallet2::refresh	(	bool	trusted_daemon,
		uint64_t	start_height,
		uint64_t &	blocks_fetched
	)

Definition at line 3049 of file wallet2.cpp.

 {
   bool received_etn = false;
   refresh(trusted_daemon, start_height, blocks_fetched, received_etn);
 }

◆ refresh() [4/4]

void tools::wallet2::refresh	(	bool	trusted_daemon,
		uint64_t	start_height,
		uint64_t &	blocks_fetched,
		bool &	received_etn,
		bool	check_pool = `true`
	)

Definition at line 3476 of file wallet2.cpp.

 {
   if (m_offline)
   {
     blocks_fetched = 0;
     received_etn = 0;
     return;
   }
  
   if(m_light_wallet) {
  
     // MyMonero get_address_info needs to be called occasionally to trigger wallet sync.
     // This call is not really needed for other purposes and can be removed if mymonero changes their backend.
     tools::COMMAND_RPC_GET_ADDRESS_INFO::response res;
  
     // Get basic info
     if(light_wallet_get_address_info(res)) {
       // Last stored block height
       uint64_t prev_height = m_light_wallet_blockchain_height;
       // Update lw heights
       m_light_wallet_scanned_block_height = res.scanned_block_height;
       m_light_wallet_blockchain_height = res.blockchain_height;
       // If new height - call new_block callback
       if(m_light_wallet_blockchain_height != prev_height)
       {
         MDEBUG("new block since last time!");
         m_callback->on_lw_new_block(m_light_wallet_blockchain_height - 1);
       }
       m_light_wallet_connected = true;
       MDEBUG("lw scanned block height: " <<  m_light_wallet_scanned_block_height);
       MDEBUG("lw blockchain height: " <<  m_light_wallet_blockchain_height);
       MDEBUG(m_light_wallet_blockchain_height-m_light_wallet_scanned_block_height << " blocks behind");
       // TODO: add wallet created block info
  
       light_wallet_get_address_txs();
     } else
       m_light_wallet_connected = false;
  
     // Lighwallet refresh done
     return;
   }
   received_etn = false;
   blocks_fetched = 0;
   uint64_t added_blocks = 0;
   size_t try_count = 0;
   crypto::hash last_tx_hash_id = m_transfers.size() ? m_transfers.back().m_txid : null_hash;
   std::list<crypto::hash> short_chain_history;
   tools::threadpool& tpool = tools::threadpool::getInstance();
   tools::threadpool::waiter waiter;
   uint64_t blocks_start_height;
   std::vector<cryptonote::block_complete_entry> blocks;
   std::vector<parsed_block> parsed_blocks;
   bool refreshed = false;
   std::shared_ptr<std::pair<std::map<std::pair<uint64_t, uint64_t>, size_t>, std::map<std::pair<std::array<char, 32>, size_t>, size_t>>> output_tracker_cache; //this is where the only usage of output_tracker cache begins
   hw::device &hwdev = m_account.get_device();
  
   // pull the first set of blocks
   get_short_chain_history(short_chain_history, (m_first_refresh_done || trusted_daemon) ? 1 : FIRST_REFRESH_GRANULARITY);
   m_run.store(true, std::memory_order_relaxed);
   if (start_height > m_blockchain.size() || m_refresh_from_block_height > m_blockchain.size()) {
     if (!start_height)
       start_height = m_refresh_from_block_height;
     // we can shortcut by only pulling hashes up to the start_height
     fast_refresh(start_height, blocks_start_height, short_chain_history);
     // regenerate the history now that we've got a full set of hashes
     short_chain_history.clear();
     get_short_chain_history(short_chain_history, (m_first_refresh_done || trusted_daemon) ? 1 : FIRST_REFRESH_GRANULARITY);
     start_height = 0;
     // and then fall through to regular refresh processing
   }
  
   // If stop() is called during fast refresh we don't need to continue
   if(!m_run.load(std::memory_order_relaxed))
     return;
   // always reset start_height to 0 to force short_chain_ history to be used on
   // subsequent pulls in this refresh.
   start_height = 0;
  
   auto keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this]() {
     if (m_encrypt_keys_after_refresh)
     {
       encrypt_keys(*m_encrypt_keys_after_refresh);
       m_encrypt_keys_after_refresh = boost::none;
     }
   });
  
   auto scope_exit_handler_hwdev = epee::misc_utils::create_scope_leave_handler([&](){hwdev.computing_key_images(false);});
   bool first = true;
   while(m_run.load(std::memory_order_relaxed))
   {
     uint64_t next_blocks_start_height;
     std::vector<cryptonote::block_complete_entry> next_blocks;
     std::vector<parsed_block> next_parsed_blocks;
     bool error;
     try
     {
       // pull the next set of blocks while we're processing the current one
       error = false;
       next_blocks.clear();
       next_parsed_blocks.clear();
       added_blocks = 0;
       if (!first && blocks.empty())
       {
         refreshed = false;
         break;
       }
       tpool.submit(&waiter, [&]{pull_and_parse_next_blocks(start_height, next_blocks_start_height, short_chain_history, blocks, parsed_blocks, next_blocks, next_parsed_blocks, error);});
  
       if (!first)
       {
         try
         {
           process_parsed_blocks(blocks_start_height, blocks, parsed_blocks, added_blocks, output_tracker_cache.get());
         }
         catch (const tools::error::out_of_hashchain_bounds_error&)
         {
           MINFO("Daemon claims next refresh block is out of hash chain bounds, resetting hash chain");
           uint64_t stop_height = m_blockchain.offset();
           std::vector<crypto::hash> tip(m_blockchain.size() - m_blockchain.offset());
           for (size_t i = m_blockchain.offset(); i < m_blockchain.size(); ++i)
             tip[i - m_blockchain.offset()] = m_blockchain[i];
           cryptonote::block b;
           generate_genesis(b);
           m_blockchain.clear();
           m_blockchain.push_back(get_block_hash(b));
           short_chain_history.clear();
           get_short_chain_history(short_chain_history);
           fast_refresh(stop_height, blocks_start_height, short_chain_history, true);
           THROW_WALLET_EXCEPTION_IF((m_blockchain.size() == stop_height || (m_blockchain.size() == 1 && stop_height == 0) ? false : true), error::wallet_internal_error, "Unexpected hashchain size");
           THROW_WALLET_EXCEPTION_IF(m_blockchain.offset() != 0, error::wallet_internal_error, "Unexpected hashchain offset");
           for (const auto &h: tip)
             m_blockchain.push_back(h);
           short_chain_history.clear();
           get_short_chain_history(short_chain_history);
           start_height = stop_height;
           throw std::runtime_error(""); // loop again
         }
         catch (const std::exception &e)
         {
           MERROR("Error parsing blocks: " << e.what());
           error = true;
         }
         blocks_fetched += added_blocks;
       }
       waiter.wait(&tpool);
       if(!first && blocks_start_height == next_blocks_start_height)
       {
         m_node_rpc_proxy.set_height(m_blockchain.size());
         refreshed = true;
         break;
       }
  
       first = false;
  
       // handle error from async fetching thread
       if (error)
       {
         throw std::runtime_error("proxy exception in refresh thread");
       }
  
       // if we've got at least 10 blocks to refresh, assume we're starting
       // a long refresh, and setup a tracking output cache if we need to
       // We hit create_output_tracker_cache before doing processing our blocks in process_parsed_blocks above( see 'first' variable)
       if (m_track_uses && (!output_tracker_cache || (output_tracker_cache->first.empty() && output_tracker_cache->second.empty())) && next_blocks.size() >= 10)
         output_tracker_cache = create_output_tracker_cache();
  
       // switch to the new blocks from the daemon
       blocks_start_height = next_blocks_start_height;
       blocks = std::move(next_blocks);
       parsed_blocks = std::move(next_parsed_blocks);
     }
     catch (const tools::error::password_needed&)
     {
       blocks_fetched += added_blocks;
       waiter.wait(&tpool);
       throw;
     }
     catch (const std::exception&)
     {
       blocks_fetched += added_blocks;
       waiter.wait(&tpool);
       if(try_count < 3)
       {
         LOG_PRINT_L1("Another try pull_blocks (try_count=" << try_count << ")...");
         first = true;
         start_height = 0;
         blocks.clear();
         parsed_blocks.clear();
         short_chain_history.clear();
         get_short_chain_history(short_chain_history, 1);
         ++try_count;
       }
       else
       {
         LOG_ERROR("pull_blocks failed, try_count=" << try_count);
         throw;
       }
     }
   }
   if(last_tx_hash_id != (m_transfers.size() ? m_transfers.back().m_txid : null_hash))
     received_etn = true;
  
   try
   {
     // If stop() is called we don't need to check pending transactions
     if (check_pool && m_run.load(std::memory_order_relaxed))
       update_pool_state(refreshed);
   }
   catch (...)
   {
     LOG_PRINT_L1("Failed to check pending transactions");
   }
  
   m_first_refresh_done = true;
  
   LOG_PRINT_L1("Refresh done, blocks received: " << blocks_fetched << ", pre v10 balance (all accounts): " << print_etn(balance_all(false)) << ", unlocked: " << print_etn(unlocked_balance_all(false)) << ", post v10 balance (all accounts): " << print_etn(balance_all(true)) << ", unlocked: " << print_etn(unlocked_balance_all(true)));
  
   try {
     // V9-->V10 PUBLIC MIGRATIONS
     // check that the local blockchain height is at least the v10 fork height + 5 blocks (so we know we don't need to scan for any more v1 outputs and they have all have 5 confs)
     //todo: write function for wallet that gets the b.major version for a given *local* blockchain height, to save hardcoding heights.
     uint64_t migration_minheight = this->nettype() == TESTNET ? 1165235 + 5 : 1175315 + 5;
     if (this->get_blockchain_current_height() > migration_minheight && this->unlocked_balance_all(false) != 0) {
         LOG_PRINT_L0("You are now on the transparent version of Electroneum and so we're giving you the chance to migrate your funds via a sweep transaction back to your address.\n Don't worry, this migration is completely free of charge. Please follow the prompts to continue.");
         std::map < uint32_t, std::map < uint32_t, std::pair <uint64_t, uint64_t>>> unlocked_balance_per_subaddress_per_account; // map of:   account index ---->  (subaddress index, pair(u-balance, unlock time))
         // for each account, grab all of the subaddress info (index, (balance, unlock))
         for (uint32_t account_index = 0; account_index < this->get_num_subaddress_accounts(); ++account_index) {
             unlocked_balance_per_subaddress_per_account[account_index] = this->unlocked_balance_per_subaddress(
                     account_index, false);
         }
         for (uint32_t i = 0; i < this->get_num_subaddress_accounts(); i++) {
             cryptonote::subaddress_index index;
             index.major = i;
             for (auto subaddress: unlocked_balance_per_subaddress_per_account[i]) {
                 index.minor = subaddress.first;
  
                 if (subaddress.second.first != 0 &&
                     subaddress.second.second == 0/*is there a fully unlocked nonzero balance /sanity check*/) {
                     cryptonote::account_public_address address = get_subaddress(index);
                     std::set <uint32_t> subaddress_source{index.minor};
                     std::vector <wallet2::pending_tx> ptx_vector = this->create_transactions_all(0,
                                                                                                  address /*dest address*/,
                                                                                                  index.major != 0 ||
                                                                                                  index.minor !=
                                                                                                  0 /*is dest a subaddress*/,
                                                                                                  1 /*one output only*/,
                                                                                                  0 /* don't mix*/,
                                                                                                  0 /*default unlock time*/,
                                                                                                  4 /*highest priority*/,
                                                                                                  vector<uint8_t>() /*empty tx extra */,
                                                                                                  index.major /*account index*/,
                                                                                                  subaddress_source /*source subaddr index*/,
                                                                                                  true /*migrate*/);
                  this->commit_tx(ptx_vector);
                 }
             }
         }
         LOG_PRINT_L0("Migration completed.");
     }
   }
    catch(...){
     THROW_WALLET_EXCEPTION(error::wallet_internal_error, "Overall migration failed but some balances may have migrated ok. Please restart the wallet and try again and contact Electroneum if the issue persists.");
    }
 }

◆ remove_obsolete_pool_txs()

void tools::wallet2::remove_obsolete_pool_txs ( const std::vector< crypto::hash > & tx_hashes )

Definition at line 3119 of file wallet2.cpp.

 {
   // remove pool txes to us that aren't in the pool anymore
   std::unordered_multimap<crypto::hash, wallet2::pool_payment_details>::iterator uit = m_unconfirmed_payments.begin();
   while (uit != m_unconfirmed_payments.end())
   {
     const crypto::hash &txid = uit->second.m_pd.m_tx_hash;
     bool found = false;
     for (const auto &it2: tx_hashes)
     {
       if (it2 == txid)
       {
         found = true;
         break;
       }
     }
     auto pit = uit++;
     if (!found)
     {
       MDEBUG("Removing " << txid << " from unconfirmed payments, not found in pool");
       m_unconfirmed_payments.erase(pit);
       if (0 != m_callback)
         m_callback->on_pool_tx_removed(txid);
     }
   }
 }

◆ rescan_blockchain()

void tools::wallet2::rescan_blockchain	(	bool	hard,
		bool	refresh = `true`,
		bool	keep_key_images = `false`
	)

Definition at line 6339 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(!hard || !keep_key_images, "Cannot preserve key images on hard rescan");
   const size_t transfers_cnt = m_transfers.size();
   crypto::hash transfers_hash{};
  
   if(hard)
   {
     clear();
     setup_new_blockchain();
   }
   else
   {
     if (keep_key_images && refresh)
       hash_m_transfers((int64_t) transfers_cnt, transfers_hash);
     clear_soft(keep_key_images);
   }
  
   if (refresh)
     this->refresh(false);
  
   if (refresh && keep_key_images)
     finish_rescan_bc_keep_key_images(transfers_cnt, transfers_hash);
 }

◆ rescan_spent()

void tools::wallet2::rescan_spent ( )

Definition at line 6287 of file wallet2.cpp.

 {
   // This is RPC call that can take a long time if there are many outputs,
   // so we call it several times, in stripes, so we don't time out spuriously
   std::vector<int> spent_status;
   spent_status.reserve(m_transfers.size());
   const size_t chunk_size = 1000;
   for (size_t start_offset = 0; start_offset < m_transfers.size(); start_offset += chunk_size)
   {
     const size_t n_outputs = std::min<size_t>(chunk_size, m_transfers.size() - start_offset);
     MDEBUG("Calling is_key_image_spent on " << start_offset << " - " << (start_offset + n_outputs - 1) << ", out of " << m_transfers.size());
     COMMAND_RPC_IS_KEY_IMAGE_SPENT::request req = AUTO_VAL_INIT(req);
     COMMAND_RPC_IS_KEY_IMAGE_SPENT::response daemon_resp = AUTO_VAL_INIT(daemon_resp);
     for (size_t n = start_offset; n < start_offset + n_outputs; ++n)
       req.key_images.push_back(string_tools::pod_to_hex(m_transfers[n].m_key_image));
     m_daemon_rpc_mutex.lock();
     bool r = invoke_http_json("/is_key_image_spent", req, daemon_resp, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "is_key_image_spent");
     THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "is_key_image_spent");
     THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::is_key_image_spent_error, get_rpc_status(daemon_resp.status));
     THROW_WALLET_EXCEPTION_IF(daemon_resp.spent_status.size() != n_outputs, error::wallet_internal_error,
       "daemon returned wrong response for is_key_image_spent, wrong amounts count = " +
       std::to_string(daemon_resp.spent_status.size()) + ", expected " +  std::to_string(n_outputs));
     std::copy(daemon_resp.spent_status.begin(), daemon_resp.spent_status.end(), std::back_inserter(spent_status));
   }
  
   // update spent status
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     transfer_details& td = m_transfers[i];
     // a view wallet may not know about key images
     if (!td.m_key_image_known || td.m_key_image_partial)
       continue;
     if (td.m_spent != (spent_status[i] != COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT))
     {
       if (td.m_spent)
       {
         LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as unspent, it was marked as spent");
         set_unspent(i);
         td.m_spent_height = 0;
       }
       else
       {
         LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as spent, it was marked as unspent");
         set_spent(i, td.m_spent_height);
         // unknown height, if this gets reorged, it might still be missed
       }
     }
   }
 }

Here is the call graph for this function:

◆ restore()

void tools::wallet2::restore	(	const std::string &	wallet_,
		const epee::wipeable_string &	password,
		const std::string &	device_name,
		bool	create_address_file = `false`
	)

Restore a wallet hold by an HW.

Creates a wallet from a device.

Parameters

wallet_	Name of wallet file
password	Password of wallet file
device_name	name of HW to use
create_address_file	Whether to create an address file
wallet_	Name of wallet file
password	Password of wallet file
device_name	device string address

Definition at line 5000 of file wallet2.cpp.

 {
   clear();
   prepare_file_names(wallet_);
  
   boost::system::error_code ignored_ec;
   if (!wallet_.empty()) {
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
   }
  
   auto &hwdev = lookup_device(device_name);
   hwdev.set_name(device_name);
   hwdev.set_network_type(m_nettype);
   hwdev.set_derivation_path(m_device_derivation_path);
   hwdev.set_callback(get_device_callback());
  
   m_account.create_from_device(hwdev);
   init_type(m_account.get_device().get_type());
   setup_keys(password);
   m_device_name = device_name;
  
   create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
   if (m_subaddress_lookahead_major == SUBADDRESS_LOOKAHEAD_MAJOR && m_subaddress_lookahead_minor == SUBADDRESS_LOOKAHEAD_MINOR)
   {
     // the default lookahead setting (50:200) is clearly too much for hardware wallet
     m_subaddress_lookahead_major = 5;
     m_subaddress_lookahead_minor = 20;
   }
   setup_new_blockchain();
   if (!wallet_.empty()) {
     store();
   }
 }

Here is the call graph for this function:

◆ rewrite()

void tools::wallet2::rewrite	(	const std::string &	wallet_name,
		const epee::wipeable_string &	password
	)

Rewrites to the wallet file for wallet upgrade (doesn't generate key, assumes it's already there)

Parameters

wallet_name	Name of wallet file (should exist)
password	Password for wallet file

Definition at line 5560 of file wallet2.cpp.

 {
   if (wallet_name.empty())
     return;
   prepare_file_names(wallet_name);
   boost::system::error_code ignored_ec;
   THROW_WALLET_EXCEPTION_IF(!boost::filesystem::exists(m_keys_file, ignored_ec), error::file_not_found, m_keys_file);
   bool r = store_keys(m_keys_file, password, m_watch_only);
   THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
 }

◆ sanity_check()

bool tools::wallet2::sanity_check	(	const std::vector< wallet2::pending_tx > &	ptx_vector,
		std::vector< cryptonote::tx_destination_entry >	dsts
	)		const

Definition at line 10070 of file wallet2.cpp.

                                                                                  {
     MDEBUG("sanity_check: " << ptx_vector.size() << " txes, " << dsts.size() << " destinations");
  
     hw::device &hwdev = m_account.get_device();
  
     THROW_WALLET_EXCEPTION_IF(ptx_vector.empty(), error::wallet_internal_error, "No transactions");
  
     if (std::all_of(ptx_vector.begin(), ptx_vector.end(), [](const pending_tx &ptx) { return ptx.tx.version == 1; })) { // we only need do tx proofs for v1
         // check every party in there does receive at least the required amount
         std::unordered_map<account_public_address, std::pair<uint64_t, bool>> required;
         for (const auto &d: dsts) {
             required[d.addr].first += d.amount;
             required[d.addr].second = d.is_subaddress;
         }
  
         // add change
         uint64_t change = 0;
         for (const auto &ptx: ptx_vector) {
             for (size_t idx: ptx.selected_transfers) //1:add the amount you're spending
                 change += m_transfers[idx].amount();
             change -= ptx.fee; //2: take off the fee
         }
         for (const auto &r: required)
             change -= r.second.first; // 3: subtract the destination required amount
         MDEBUG("Adding " << cryptonote::print_etn(change) << " expected change");
  
         // for all txes that have actual change, check change is coming back to the sending wallet
         for (const pending_tx &ptx: ptx_vector) {
             if (ptx.change_dts.amount == 0)
                 continue;
             THROW_WALLET_EXCEPTION_IF(
                     m_subaddresses.find(ptx.change_dts.addr.m_spend_public_key) == m_subaddresses.end(),
                     error::wallet_internal_error, "Change address is not ours");
             required[ptx.change_dts.addr].first += ptx.change_dts.amount;
             required[ptx.change_dts.addr].second = ptx.change_dts.is_subaddress;
         }
  
  
         for (const auto &r: required) {
             const account_public_address &address = r.first;
             const crypto::public_key &view_pkey = address.m_view_public_key;
  
             uint64_t total_received = 0;
  
             for (const auto &ptx: ptx_vector) {
                 uint64_t received = 0;
                 try {
                     std::string proof = get_tx_proof(ptx.tx, ptx.tx_key, ptx.additional_tx_keys, address,
                                                      r.second.second,
                                                      "automatic-sanity-check");
                     check_tx_proof(ptx.tx, address, r.second.second, "automatic-sanity-check", proof, received);
                 }
                 catch (const std::exception &e) { received = 0; }
                 total_received += received;
             }
  
             std::stringstream ss;
             ss << "Total received by "
                << cryptonote::get_account_address_as_str(m_nettype, r.second.second, address)
                << ": "
                << cryptonote::print_etn(total_received) << ", expected " << cryptonote::print_etn(r.second.first);
             MDEBUG(ss.str());
             THROW_WALLET_EXCEPTION_IF(total_received < r.second.first, error::wallet_internal_error, ss.str());
         }
     } // end of v1 sanity check
     else {
         // for all txes that have actual change, check change is coming back to the sending wallet
         for (const pending_tx &ptx: ptx_vector) {
             if (ptx.change_dts.amount == 0)
                 continue;
             THROW_WALLET_EXCEPTION_IF(
                     m_subaddresses.find(ptx.change_dts.addr.m_spend_public_key) == m_subaddresses.end(),
                     error::wallet_internal_error, "Change address is not ours");
         }
     }
     return true;
 }

Here is the call graph for this function:

◆ save_multisig_tx() [1/4]

bool tools::wallet2::save_multisig_tx	(	const multisig_tx_set &	txs,
		const std::string &	filename
	)

Definition at line 7268 of file wallet2.cpp.

 {
   std::string ciphertext = save_multisig_tx(txs);
   if (ciphertext.empty())
     return false;
   return epee::file_io_utils::save_string_to_file(filename, ciphertext);
 }

Here is the call graph for this function:

◆ save_multisig_tx() [2/4]

std::string tools::wallet2::save_multisig_tx ( const std::vector< pending_tx > & ptx_vector )

Definition at line 7291 of file wallet2.cpp.

 {
   return save_multisig_tx(make_multisig_tx_set(ptx_vector));
 }

◆ save_multisig_tx() [3/4]

bool tools::wallet2::save_multisig_tx	(	const std::vector< pending_tx > &	ptx_vector,
		const std::string &	filename
	)

Definition at line 7296 of file wallet2.cpp.

 {
   std::string ciphertext = save_multisig_tx(ptx_vector);
   if (ciphertext.empty())
     return false;
   return epee::file_io_utils::save_string_to_file(filename, ciphertext);
 }

Here is the call graph for this function:

◆ save_multisig_tx() [4/4]

std::string tools::wallet2::save_multisig_tx ( multisig_tx_set txs )

Definition at line 7230 of file wallet2.cpp.

 {
   LOG_PRINT_L0("saving " << txs.m_ptx.size() << " multisig transactions");
  
   // txes generated, get rid of used k values
   for (size_t n = 0; n < txs.m_ptx.size(); ++n)
     for (size_t idx: txs.m_ptx[n].construction_data.selected_transfers)
       m_transfers[idx].m_multisig_k.clear();
  
   // zero out some data we don't want to share
   for (auto &ptx: txs.m_ptx)
   {
     for (auto &e: ptx.construction_data.sources)
       e.multisig_kLRki.k = rct::zero();
   }
  
   for (auto &ptx: txs.m_ptx)
   {
     // Get decrypted payment id from pending_tx
     ptx.construction_data = get_construction_data_with_decrypted_short_payment_id(ptx, m_account.get_device());
   }
  
   // save as binary
   std::ostringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   try
   {
     ar << txs;
   }
   catch (...)
   {
     return std::string();
   }
   LOG_PRINT_L2("Saving multisig unsigned tx data: " << oss.str());
   std::string ciphertext = encrypt_with_view_secret_key(oss.str());
   return std::string(MULTISIG_UNSIGNED_TX_PREFIX) + ciphertext;
 }

Here is the call graph for this function:

◆ save_tx()

bool tools::wallet2::save_tx	(	const std::vector< pending_tx > &	ptx_vector,
		const std::string &	filename
	)		const

Definition at line 6774 of file wallet2.cpp.

 {
   LOG_PRINT_L0("saving " << ptx_vector.size() << " transactions");
   std::string ciphertext = dump_tx_to_str(ptx_vector);
   if (ciphertext.empty())
     return false;
   return epee::file_io_utils::save_string_to_file(filename, ciphertext);
 }

Here is the call graph for this function:

◆ segregate_pre_fork_outputs() [1/2]

bool tools::wallet2::segregate_pre_fork_outputs ( ) const

inline

Definition at line 1087 of file wallet2.h.

1087 { return m_segregate_pre_fork_outputs; }

◆ segregate_pre_fork_outputs() [2/2]

void tools::wallet2::segregate_pre_fork_outputs ( bool value )

inline

Definition at line 1088 of file wallet2.h.

1088 { m_segregate_pre_fork_outputs = value; }

◆ segregation_height() [1/2]

uint64_t tools::wallet2::segregation_height ( ) const

inline

Definition at line 1091 of file wallet2.h.

1091 { return m_segregation_height; }

◆ segregation_height() [2/2]

void tools::wallet2::segregation_height ( uint64_t height )

inline

Definition at line 1092 of file wallet2.h.

1092 { m_segregation_height = height; }

◆ select_available_mixable_outputs()

std::vector< size_t > tools::wallet2::select_available_mixable_outputs ( )

Definition at line 10654 of file wallet2.cpp.

 {
   // request all outputs with at least as many instances as the min ring size
   return select_available_outputs_from_histogram(get_min_ring_size(), true, true, true);
 }

◆ select_available_outputs()

std::vector< size_t > tools::wallet2::select_available_outputs ( const std::function< bool(const transfer_details &td)> & f ) const

Definition at line 10545 of file wallet2.cpp.

 {
   std::vector<size_t> outputs;
   size_t n = 0;
   for (transfer_container::const_iterator i = m_transfers.begin(); i != m_transfers.end(); ++i, ++n)
   {
     if (i->m_spent)
       continue;
     if (i->m_frozen)
       continue;
     if (i->m_key_image_partial)
       continue;
     if (!is_transfer_unlocked(*i))
       continue;
     if (f(*i))
       outputs.push_back(n);
   }
   return outputs;
 }

◆ select_available_outputs_from_histogram()

std::vector< size_t > tools::wallet2::select_available_outputs_from_histogram	(	uint64_t	count,
		bool	atleast,
		bool	unlocked,
		bool	allow_rct
	)

Definition at line 10582 of file wallet2.cpp.

 {
   cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t = AUTO_VAL_INIT(req_t);
   cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t = AUTO_VAL_INIT(resp_t);
   m_daemon_rpc_mutex.lock();
   if (is_trusted_daemon())
     req_t.amounts = get_unspent_amounts_vector();
   req_t.min_count = count;
   req_t.max_count = 0;
   req_t.unlocked = unlocked;
   req_t.recent_cutoff = 0;
   bool r = invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "select_available_outputs_from_histogram");
   THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
   THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
  
   std::set<uint64_t> mixable;
   for (const auto &i: resp_t.histogram)
   {
     mixable.insert(i.amount);
   }
  
   return select_available_outputs([mixable, atleast, allow_rct](const transfer_details &td) {
     if (!allow_rct && td.is_rct())
       return false;
     const uint64_t amount = td.is_rct() ? 0 : td.amount();
     if (atleast) {
       if (mixable.find(amount) != mixable.end())
         return true;
     }
     else {
       if (mixable.find(amount) == mixable.end())
         return true;
     }
     return false;
   });
 }

Here is the call graph for this function:

◆ select_available_unmixable_outputs()

std::vector< size_t > tools::wallet2::select_available_unmixable_outputs ( )

Definition at line 10648 of file wallet2.cpp.

 {
   // request all outputs with less instances than the min ring size
   return select_available_outputs_from_histogram(get_min_ring_size(), false, true, false);
 }

◆ serialize()

template<class t_archive >

void tools::wallet2::serialize	(	t_archive &	a,
		const unsigned int	ver
	)

inline

Definition at line 902 of file wallet2.h.

     {
       uint64_t dummy_refresh_height = 0; // moved to keys file
       if(ver < 5)
         return;
       if (ver < 19)
       {
         std::vector<crypto::hash> blockchain;
         a & blockchain;
         for (const auto &b: blockchain)
         {
           m_blockchain.push_back(b);
         }
       }
       else
       {
         a & m_blockchain;
       }
       a & m_transfers;
       a & m_account_public_address;
       a & m_key_images;
       if(ver < 6)
         return;
       a & m_unconfirmed_txs;
       if(ver < 7)
         return;
       a & m_payments;
       if(ver < 8)
         return;
       a & m_tx_keys;
       if(ver < 9)
         return;
       a & m_confirmed_txs;
       if(ver < 11)
         return;
       a & dummy_refresh_height;
       if(ver < 12)
         return;
       a & m_tx_notes;
       if(ver < 13)
         return;
       if (ver < 17)
       {
         // we're loading an old version, where m_unconfirmed_payments was a std::map
         std::unordered_map<crypto::hash, payment_details> m;
         a & m;
         for (std::unordered_map<crypto::hash, payment_details>::const_iterator i = m.begin(); i != m.end(); ++i)
           m_unconfirmed_payments.insert(std::make_pair(i->first, pool_payment_details{i->second, false}));
       }
       if(ver < 14)
         return;
       if(ver < 15)
       {
         // we're loading an older wallet without a pubkey map, rebuild it
         for (size_t i = 0; i < m_transfers.size(); ++i)
         {
           const transfer_details &td = m_transfers[i];
           const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
           const cryptonote::txout_to_key &o = boost::get<const cryptonote::txout_to_key>(out.target);
           m_pub_keys.emplace(o.key, i);
         }
         return;
       }
       a & m_pub_keys;
       if(ver < 16)
         return;
       a & m_address_book;
       if(ver < 17)
         return;
       if (ver < 22)
       {
         // we're loading an old version, where m_unconfirmed_payments payload was payment_details
         std::unordered_multimap<crypto::hash, payment_details> m;
         a & m;
         for (const auto &i: m)
           m_unconfirmed_payments.insert(std::make_pair(i.first, pool_payment_details{i.second, false}));
       }
       if(ver < 18)
         return;
       a & m_scanned_pool_txs[0];
       a & m_scanned_pool_txs[1];
       if (ver < 20)
         return;
       a & m_subaddresses;
       std::unordered_map<cryptonote::subaddress_index, crypto::public_key> dummy_subaddresses_inv;
       a & dummy_subaddresses_inv;
       a & m_subaddress_labels;
       a & m_additional_tx_keys;
       if(ver < 21)
         return;
       a & m_attributes;
       if(ver < 22)
         return;
       a & m_unconfirmed_payments;
       if(ver < 23)
         return;
       a & m_account_tags;
       if(ver < 24)
         return;
       a & m_ring_history_saved;
       if(ver < 25)
         return;
       a & m_last_block_reward;
       if(ver < 26)
         return;
       a & m_tx_device;
       if(ver < 27)
         return;
       a & m_device_last_key_image_sync;
       if(ver < 28)
         return;
       a & m_cold_key_images;
       if(ver < 29)
           return;
       a & m_chainstate_indexes;
     }

◆ set_account_tag()

void tools::wallet2::set_account_tag	(	const std::set< uint32_t > &	account_indices,
		const std::string &	tag
	)

Set a tag to the given accounts.

Parameters

account_indices	Indices of accounts.
tag	Tag's name. If empty, the accounts become untagged.

Definition at line 11846 of file wallet2.cpp.

 {
   for (uint32_t account_index : account_indices)
   {
     THROW_WALLET_EXCEPTION_IF(account_index >= get_num_subaddress_accounts(), error::wallet_internal_error, "Account index out of bound");
     if (m_account_tags.second[account_index] == tag)
       MDEBUG("This tag is already assigned to this account");
     else
       m_account_tags.second[account_index] = tag;
   }
   get_account_tags();
 }

◆ set_account_tag_description()

void tools::wallet2::set_account_tag_description	(	const std::string &	tag,
		const std::string &	description
	)

Set the label of the given tag.

Parameters

tag	Tag's name (which must be non-empty).
description	Tag's description.

Definition at line 11859 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(tag.empty(), error::wallet_internal_error, "Tag must not be empty");
   THROW_WALLET_EXCEPTION_IF(m_account_tags.first.count(tag) == 0, error::wallet_internal_error, "Tag is unregistered");
   m_account_tags.first[tag] = description;
 }

◆ set_attribute()

void tools::wallet2::set_attribute	(	const std::string &	key,
		const std::string &	value
	)

Definition at line 11803 of file wallet2.cpp.

 {
   m_attributes[key] = value;
 }

◆ set_blackballed_outputs()

bool tools::wallet2::set_blackballed_outputs	(	const std::vector< std::pair< uint64_t, uint64_t >> &	outputs,
		bool	add = `false`
	)

Definition at line 7973 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
   try
   {
     bool ret = true;
     if (!add)
       ret &= m_ringdb->clear_blackballs();
     ret &= m_ringdb->blackball(outputs);
     return ret;
   }
   catch (const std::exception &e) { return false; }
 }

◆ set_confirm_backlog_threshold()

void tools::wallet2::set_confirm_backlog_threshold ( uint32_t threshold )

inline

Definition at line 1081 of file wallet2.h.

1081 { m_confirm_backlog_threshold = threshold; };

◆ set_daemon()

bool tools::wallet2::set_daemon	(	std::string	daemon_address = `"http://localhost:8080"`,
		boost::optional< epee::net_utils::http::login >	daemon_login = `boost::none`,
		bool	trusted_daemon = `true`,
		epee::net_utils::ssl_options_t	ssl_options = `epee::net_utils::ssl_support_t::e_ssl_support_autodetect`
	)

Definition at line 1267 of file wallet2.cpp.

 {
   boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
  
   if(m_http_client.is_connected())
     m_http_client.disconnect();
   m_daemon_address = std::move(daemon_address);
   m_daemon_login = std::move(daemon_login);
   m_trusted_daemon = trusted_daemon;
  
   MINFO("setting daemon to " << get_daemon_address());
   return m_http_client.set_server(get_daemon_address(), get_daemon_login(), std::move(ssl_options));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_default_priority()

void tools::wallet2::set_default_priority ( uint32_t p )

inline

Definition at line 1066 of file wallet2.h.

1066 { m_default_priority = p; }

◆ set_description()

void tools::wallet2::set_description ( const std::string & description )

Definition at line 11816 of file wallet2.cpp.

 {
   set_attribute(ATTRIBUTE_DESCRIPTION, description);
 }

◆ set_light_wallet()

void tools::wallet2::set_light_wallet ( bool light_wallet )

inline

Definition at line 772 of file wallet2.h.

772 { m_light_wallet = light_wallet; }

tools::wallet2::light_wallet

bool light_wallet() const

Checks if light wallet. A light wallet sends view key to a server where the blockchain is scanned.

Definition: wallet2.h:771

Here is the call graph for this function:

◆ set_min_output_count()

void tools::wallet2::set_min_output_count ( uint32_t count )

inline

Definition at line 1073 of file wallet2.h.

1073 { m_min_output_count = count; }

Here is the call graph for this function:

◆ set_min_output_value()

void tools::wallet2::set_min_output_value ( uint64_t value )

inline

Definition at line 1075 of file wallet2.h.

1075 { m_min_output_value = value; }

◆ set_offline()

void tools::wallet2::set_offline ( bool offline = true )

Definition at line 5700 of file wallet2.cpp.

 {
   m_offline = offline;
   m_http_client.set_auto_connect(!offline);
   if (offline)
   {
     boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
     if(m_http_client.is_connected())
       m_http_client.disconnect();
   }
 }

◆ set_refresh_from_block_height()

void tools::wallet2::set_refresh_from_block_height ( uint64_t height )

inline

Definition at line 736 of file wallet2.h.

736 {m_refresh_from_block_height = height;}

◆ set_refresh_type()

void tools::wallet2::set_refresh_type ( RefreshType refresh_type )

inline

Definition at line 815 of file wallet2.h.

815 { m_refresh_type = refresh_type; }

◆ set_ring()

bool tools::wallet2::set_ring	(	const crypto::key_image &	key_image,
		const std::vector< uint64_t > &	outs,
		bool	relative
	)

Definition at line 7853 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
  
   try { return m_ringdb->set_ring(get_ringdb_key(), key_image, outs, relative); }
   catch (const std::exception &e) { return false; }
 }

◆ set_ring_database()

bool tools::wallet2::set_ring_database ( const std::string & filename )

Definition at line 7746 of file wallet2.cpp.

 {
   m_ring_database = filename;
   MINFO("ringdb path set to " << filename);
   m_ringdb.reset();
   if (!m_ring_database.empty())
   {
     try
     {
       cryptonote::block b;
       generate_genesis(b);
       m_ringdb.reset(new tools::ringdb(m_ring_database, epee::string_tools::pod_to_hex(get_block_hash(b))));
     }
     catch (const std::exception &e)
     {
       MERROR("Failed to initialize ringdb: " << e.what());
       m_ring_database = "";
       return false;
     }
   }
   return true;
 }

Here is the call graph for this function:

◆ set_seed_language()

void tools::wallet2::set_seed_language ( const std::string & language )

Sets the seed language.

Parameters

language Seed language to set to

Definition at line 1424 of file wallet2.cpp.

 {
   seed_language = language;
 }

◆ set_subaddress_label()

void tools::wallet2::set_subaddress_label	(	const cryptonote::subaddress_index &	index,
		const std::string &	label
	)

Definition at line 1527 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(index.major >= m_subaddress_labels.size(), error::account_index_outofbound);
   THROW_WALLET_EXCEPTION_IF(index.minor >= m_subaddress_labels[index.major].size(), error::address_index_outofbound);
   m_subaddress_labels[index.major][index.minor] = label;
 }

Here is the caller graph for this function:

◆ set_subaddress_lookahead()

void tools::wallet2::set_subaddress_lookahead	(	size_t	major,
		size_t	minor
	)

Definition at line 1534 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(major > 0xffffffff, error::wallet_internal_error, "Subaddress major lookahead is too large");
   THROW_WALLET_EXCEPTION_IF(minor > 0xffffffff, error::wallet_internal_error, "Subaddress minor lookahead is too large");
   m_subaddress_lookahead_major = major;
   m_subaddress_lookahead_minor = minor;
 }

Here is the caller graph for this function:

◆ set_trusted_daemon()

void tools::wallet2::set_trusted_daemon ( bool trusted )

inline

Definition at line 760 of file wallet2.h.

760 { m_trusted_daemon = trusted; }

◆ set_tx_device_aux()

void tools::wallet2::set_tx_device_aux	(	const crypto::hash &	txid,
		const std::string &	aux
	)

Definition at line 11790 of file wallet2.cpp.

 {
   m_tx_device[txid] = aux;
 }

◆ set_tx_key()

void tools::wallet2::set_tx_key	(	const crypto::hash &	txid,
		const crypto::secret_key &	tx_key,
		const std::vector< crypto::secret_key > &	additional_tx_keys
	)

Definition at line 10790 of file wallet2.cpp.

 {
   // fetch tx from daemon and check if secret keys agree with corresponding public keys
   COMMAND_RPC_GET_TRANSACTIONS::request req = AUTO_VAL_INIT(req);
   req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
   req.decode_as_json = false;
   req.prune = true;
   COMMAND_RPC_GET_TRANSACTIONS::response res = AUTO_VAL_INIT(res);
   bool r;
   {
     const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex}; 
     r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
   }
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
   THROW_WALLET_EXCEPTION_IF(res.txs.size() != 1, error::wallet_internal_error,
     "daemon returned wrong response for gettransactions, wrong txs count = " +
     std::to_string(res.txs.size()) + ", expected 1");
   cryptonote::transaction tx;
   crypto::hash tx_hash;
   THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(res.txs[0], tx, tx_hash), error::wallet_internal_error,
       "Failed to get transaction from daemon");
   THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "txid mismatch");
   std::vector<tx_extra_field> tx_extra_fields;
   THROW_WALLET_EXCEPTION_IF(!parse_tx_extra(tx.extra, tx_extra_fields), error::wallet_internal_error, "Transaction extra has unsupported format");
   tx_extra_pub_key pub_key_field;
   bool found = false;
   size_t index = 0;
   while (find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, index++))
   {
     crypto::public_key calculated_pub_key;
     crypto::secret_key_to_public_key(tx_key, calculated_pub_key);
     if (calculated_pub_key == pub_key_field.pub_key)
     {
       found = true;
       break;
     }
   }
   THROW_WALLET_EXCEPTION_IF(!found, error::wallet_internal_error, "Given tx secret key doesn't agree with the tx public key in the blockchain");
   tx_extra_additional_pub_keys additional_tx_pub_keys;
   find_tx_extra_field_by_type(tx_extra_fields, additional_tx_pub_keys);
   THROW_WALLET_EXCEPTION_IF(additional_tx_keys.size() != additional_tx_pub_keys.data.size(), error::wallet_internal_error, "The number of additional tx secret keys doesn't agree with the number of additional tx public keys in the blockchain" );
   m_tx_keys.insert(std::make_pair(txid, tx_key));
   m_additional_tx_keys.insert(std::make_pair(txid, additional_tx_keys));
 }

Here is the call graph for this function:

◆ set_tx_note()

void tools::wallet2::set_tx_note	(	const crypto::hash &	txid,
		const std::string &	note
	)

Definition at line 11777 of file wallet2.cpp.

 {
   m_tx_notes[txid] = note;
 }

◆ set_tx_notify()

void tools::wallet2::set_tx_notify ( const std::shared_ptr< tools::Notify > & notify )

inline

Definition at line 1369 of file wallet2.h.

1369 { m_tx_notify = notify; }

◆ setup_background_mining() [1/2]

BackgroundMiningSetupType tools::wallet2::setup_background_mining ( ) const

inline

Definition at line 1099 of file wallet2.h.

1099 { return m_setup_background_mining; }

◆ setup_background_mining() [2/2]

void tools::wallet2::setup_background_mining ( BackgroundMiningSetupType value )

inline

Definition at line 1100 of file wallet2.h.

1100 { m_setup_background_mining = value; }

◆ sign()

std::string tools::wallet2::sign ( const std::string & data ) const

Definition at line 11866 of file wallet2.cpp.

 {
   crypto::hash hash;
   crypto::cn_fast_hash(data.data(), data.size(), hash);
   const cryptonote::account_keys &keys = m_account.get_keys();
   crypto::signature signature;
   crypto::generate_signature(hash, keys.m_account_address.m_spend_public_key, keys.m_spend_secret_key, signature);
   return std::string("SigV1") + tools::base58::encode(std::string((const char *)&signature, sizeof(signature)));
 }

Here is the call graph for this function:

◆ sign_multisig_participant()

std::string tools::wallet2::sign_multisig_participant ( const std::string & data ) const

sign_multisig_participant signs given message with the multisig public signer key

Parameters

data	message to sign

Exceptions

if	wallet is not multisig

Returns: signature

Definition at line 11899 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
  
   crypto::hash hash;
   crypto::cn_fast_hash(data.data(), data.size(), hash);
   const cryptonote::account_keys &keys = m_account.get_keys();
   crypto::signature signature;
   crypto::generate_signature(hash, get_multisig_signer_public_key(), keys.m_spend_secret_key, signature);
   return MULTISIG_SIGNATURE_MAGIC + tools::base58::encode(std::string((const char *)&signature, sizeof(signature)));
 }

Here is the call graph for this function:

◆ sign_multisig_tx()

bool tools::wallet2::sign_multisig_tx	(	multisig_tx_set &	exported_txs,
		std::vector< crypto::hash > &	txids
	)

Definition at line 7406 of file wallet2.cpp.

 {
   THROW_WALLET_EXCEPTION_IF(exported_txs.m_ptx.empty(), error::wallet_internal_error, "No tx found");
  
   const crypto::public_key local_signer = get_multisig_signer_public_key();
  
   THROW_WALLET_EXCEPTION_IF(exported_txs.m_signers.find(local_signer) != exported_txs.m_signers.end(),
       error::wallet_internal_error, "Transaction already signed by this private key");
   THROW_WALLET_EXCEPTION_IF(exported_txs.m_signers.size() > m_multisig_threshold,
       error::wallet_internal_error, "Transaction was signed by too many signers");
   THROW_WALLET_EXCEPTION_IF(exported_txs.m_signers.size() == m_multisig_threshold,
       error::wallet_internal_error, "Transaction is already fully signed");
  
   txids.clear();
  
   // sign the transactions
   for (size_t n = 0; n < exported_txs.m_ptx.size(); ++n)
   {
     tools::wallet2::pending_tx &ptx = exported_txs.m_ptx[n];
     THROW_WALLET_EXCEPTION_IF(ptx.multisig_sigs.empty(), error::wallet_internal_error, "No signatures found in multisig tx");
     tools::wallet2::tx_construction_data &sd = ptx.construction_data;
     LOG_PRINT_L1(" " << (n+1) << ": " << sd.sources.size() << " inputs, mixin " << (sd.sources[0].outputs.size()-1) <<
         ", signed by " << exported_txs.m_signers.size() << "/" << m_multisig_threshold);
     cryptonote::transaction tx;
     rct::multisig_out msout = ptx.multisig_sigs.front().msout;
     auto sources = sd.sources;
     rct::RCTConfig rct_config = sd.rct_config;
     bool r = cryptonote::construct_tx_with_tx_key(m_account.get_keys(), m_subaddresses, sources, sd.splitted_dsts, ptx.change_dts.addr, sd.extra, tx, sd.unlock_time, ptx.tx_key, ptx.additional_tx_keys, sd.use_rct, rct_config, &msout, false, 0 /*===default value*/, this->m_nettype);
     THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, sd.unlock_time, m_nettype);
  
     THROW_WALLET_EXCEPTION_IF(get_transaction_prefix_hash (tx) != get_transaction_prefix_hash(ptx.tx),
         error::wallet_internal_error, "Transaction prefix does not match data");
  
     // Tests passed, sign
     std::vector<unsigned int> indices;
     for (const auto &source: sources)
       indices.push_back(source.real_output);
  
     for (auto &sig: ptx.multisig_sigs)
     {
       if (sig.ignore.find(local_signer) == sig.ignore.end())
       {
         ptx.tx.rct_signatures = sig.sigs;
  
         rct::keyV k;
         for (size_t idx: sd.selected_transfers)
           k.push_back(get_multisig_k(idx, sig.used_L));
  
         rct::key skey = rct::zero();
         for (const auto &msk: get_account().get_multisig_keys())
         {
           crypto::public_key pmsk = get_multisig_signing_public_key(msk);
  
           if (sig.signing_keys.find(pmsk) == sig.signing_keys.end())
           {
             sc_add(skey.bytes, skey.bytes, rct::sk2rct(msk).bytes);
             sig.signing_keys.insert(pmsk);
           }
         }
         THROW_WALLET_EXCEPTION_IF(!rct::signMultisig(ptx.tx.rct_signatures, indices, k, sig.msout, skey),
             error::wallet_internal_error, "Failed signing, transaction likely malformed");
  
         sig.sigs = ptx.tx.rct_signatures;
       }
     }
  
     const bool is_last = exported_txs.m_signers.size() + 1 >= m_multisig_threshold;
     if (is_last)
     {
       // when the last signature on a multisig tx is made, we select the right
       // signature to plug into the final tx
       bool found = false;
       for (const auto &sig: ptx.multisig_sigs)
       {
         if (sig.ignore.find(local_signer) == sig.ignore.end() && !keys_intersect(sig.ignore, exported_txs.m_signers))
         {
           THROW_WALLET_EXCEPTION_IF(found, error::wallet_internal_error, "More than one transaction is final");
           ptx.tx.rct_signatures = sig.sigs;
           found = true;
         }
       }
       THROW_WALLET_EXCEPTION_IF(!found, error::wallet_internal_error,
           "Final signed transaction not found: this transaction was likely made without our export data, so we cannot sign it");
       const crypto::hash txid = get_transaction_hash(ptx.tx);
       if (store_tx_info())
       {
         m_tx_keys.insert(std::make_pair(txid, ptx.tx_key));
         m_additional_tx_keys.insert(std::make_pair(txid, ptx.additional_tx_keys));
       }
       txids.push_back(txid);
     }
   }
  
   // txes generated, get rid of used k values
   for (size_t n = 0; n < exported_txs.m_ptx.size(); ++n)
     for (size_t idx: exported_txs.m_ptx[n].construction_data.selected_transfers)
       m_transfers[idx].m_multisig_k.clear();
  
   exported_txs.m_signers.insert(get_multisig_signer_public_key());
  
   return true;
 }

Here is the call graph for this function:

◆ sign_multisig_tx_from_file()

bool tools::wallet2::sign_multisig_tx_from_file	(	const std::string &	filename,
		std::vector< crypto::hash > &	txids,
		std::function< bool(const multisig_tx_set &)>	accept_func
	)

Definition at line 7517 of file wallet2.cpp.

 {
   multisig_tx_set exported_txs;
   if(!load_multisig_tx_from_file(filename, exported_txs))
     return false;
  
   if (accept_func && !accept_func(exported_txs))
   {
     LOG_PRINT_L1("Transactions rejected by callback");
     return false;
   }
   return sign_multisig_tx_to_file(exported_txs, filename, txids);
 }

◆ sign_multisig_tx_to_file()

bool tools::wallet2::sign_multisig_tx_to_file	(	multisig_tx_set &	exported_txs,
		const std::string &	filename,
		std::vector< crypto::hash > &	txids
	)

Definition at line 7509 of file wallet2.cpp.

 {
   bool r = sign_multisig_tx(exported_txs, txids);
   if (!r)
     return false;
   return save_multisig_tx(exported_txs, filename);
 }

◆ sign_tx() [1/3]

bool tools::wallet2::sign_tx	(	const std::string &	unsigned_filename,
		const std::string &	signed_filename,
		std::vector< wallet2::pending_tx > &	ptx,
		std::function< bool(const unsigned_tx_set &)>	accept_func = `NULL`,
		bool	export_raw = `false`
	)

Definition at line 6901 of file wallet2.cpp.

 {
   unsigned_tx_set exported_txs;
   if(!load_unsigned_tx(unsigned_filename, exported_txs))
     return false;
  
   if (accept_func && !accept_func(exported_txs))
   {
     LOG_PRINT_L1("Transactions rejected by callback");
     return false;
   }
   return sign_tx(exported_txs, signed_filename, txs, export_raw);
 }

Here is the caller graph for this function:

◆ sign_tx() [2/3]

bool tools::wallet2::sign_tx	(	unsigned_tx_set &	exported_txs,
		const std::string &	signed_filename,
		std::vector< wallet2::pending_tx > &	ptx,
		bool	export_raw = `false`
	)

Definition at line 7061 of file wallet2.cpp.

 {
   // sign the transactions
   signed_tx_set signed_txes;
   std::string ciphertext = sign_tx_dump_to_str(exported_txs, txs, signed_txes);
   if (ciphertext.empty())
   {
     LOG_PRINT_L0("Failed to sign unsigned_tx_set");
     return false;
   }
  
   if (!epee::file_io_utils::save_string_to_file(signed_filename, ciphertext))
   {
     LOG_PRINT_L0("Failed to save file to " << signed_filename);
     return false;
   }
   // export signed raw tx without encryption
   if (export_raw)
   {
     for (size_t i = 0; i < signed_txes.ptx.size(); ++i)
     {
       std::string tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(signed_txes.ptx[i].tx));
       std::string raw_filename = signed_filename + "_raw" + (signed_txes.ptx.size() == 1 ? "" : ("_" + std::to_string(i)));
       if (!epee::file_io_utils::save_string_to_file(raw_filename, tx_as_hex))
       {
         LOG_PRINT_L0("Failed to save file to " << raw_filename);
         return false;
       }
     }
   }
   return true;
 }

Here is the call graph for this function:

◆ sign_tx() [3/3]

bool tools::wallet2::sign_tx	(	unsigned_tx_set &	exported_txs,
		std::vector< wallet2::pending_tx > &	ptx,
		signed_tx_set &	signed_txs
	)

Definition at line 6915 of file wallet2.cpp.

 {
   import_outputs(exported_txs.transfers);
  
   // sign the transactions
   for (size_t n = 0; n < exported_txs.txes.size(); ++n)
   {
     tools::wallet2::tx_construction_data &sd = exported_txs.txes[n];
     THROW_WALLET_EXCEPTION_IF(sd.sources.empty(), error::wallet_internal_error, "Empty sources");
     LOG_PRINT_L1(" " << (n+1) << ": " << sd.sources.size() << " inputs, ring size " << sd.sources[0].outputs.size());
     signed_txes.ptx.push_back(pending_tx());
     tools::wallet2::pending_tx &ptx = signed_txes.ptx.back();
     rct::RCTConfig rct_config = sd.rct_config;
     crypto::secret_key tx_key;
     std::vector<crypto::secret_key> additional_tx_keys;
     rct::multisig_out msout;
  
     // NB no early blocks this time for v3 transactions, as nobody should be sending v3 transactions before their v2 (migration) tx have confirmed. V2 confirmations always take place at, or after, the fork block.
     // todo: 4.0.0.0 Migrate vs send regular tx.
     uint16_t hard_fork_version = use_fork_rules(CURRENT_HARDFORK_VERSION, 0) ? CURRENT_HARDFORK_VERSION : (CURRENT_HARDFORK_VERSION - 1);
     bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sd.sources, sd.splitted_dsts, sd.change_dts.addr, sd.extra, ptx.tx, sd.unlock_time, tx_key, additional_tx_keys, sd.use_rct, rct_config, m_multisig ? &msout : NULL, m_account_major_offset, this->m_nettype);
     THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, sd.unlock_time, m_nettype);
     // we don't test tx size, because we don't know the current limit, due to not having a blockchain,
     // and it's a bit pointless to fail there anyway, since it'd be a (good) guess only. We sign anyway,
     // and if we really go over limit, the daemon will reject when it gets submitted. Chances are it's
     // OK anyway since it was generated in the first place, and rerolling should be within a few bytes.
  
     // normally, the tx keys are saved in commit_tx, when the tx is actually sent to the daemon.
     // we can't do that here since the tx will be sent from the compromised wallet, which we don't want
     // to see that info, so we save it here
     if (store_tx_info())
     {
       const crypto::hash txid = get_transaction_hash(ptx.tx);
       m_tx_keys.insert(std::make_pair(txid, tx_key));
       m_additional_tx_keys.insert(std::make_pair(txid, additional_tx_keys));
     }
  
     std::string key_images;
  
     if(ptx.tx.version < 3) {
         bool all_are_txin_to_key = std::all_of(ptx.tx.vin.begin(), ptx.tx.vin.end(), [&](const txin_v &s_e) -> bool {
             CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
             key_images += boost::to_string(in.k_image) + " ";
             return true;
         });
         THROW_WALLET_EXCEPTION_IF(!all_are_txin_to_key, error::unexpected_txin_type, ptx.tx);
     }else{
         bool all_are_txin_to_key_public = std::all_of(ptx.tx.vin.begin(), ptx.tx.vin.end(), [&](const txin_v &s_e) -> bool {
             CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key_public, in, false);
             return true;
         });
         THROW_WALLET_EXCEPTION_IF(!all_are_txin_to_key_public, error::unexpected_txin_type, ptx.tx);
     }
     if(ptx.tx.version > 1) {
       bool all_are_txout_to_key_public = std::all_of(ptx.tx.vout.begin(), ptx.tx.vout.end(), [&](const tx_out &s_e) -> bool {
           CHECKED_GET_SPECIFIC_VARIANT(s_e.target, const txout_to_key_public, in, false);
           return true;
       });
       THROW_WALLET_EXCEPTION_IF(!all_are_txout_to_key_public, error::unexpected_txout_type, ptx.tx);
     }
     ptx.key_images = key_images;
     ptx.fee = 0;
     for (const auto &i: sd.sources) ptx.fee += i.amount;
     for (const auto &i: sd.splitted_dsts) ptx.fee -= i.amount;
     ptx.dust = 0;
     ptx.dust_added_to_fee = false;
     ptx.change_dts = sd.change_dts;
     ptx.selected_transfers = sd.selected_transfers;
     ptx.tx_key = rct::rct2sk(rct::identity()); // don't send it back to the untrusted view wallet
     ptx.dests = sd.dests;
     ptx.construction_data = sd;
  
     txs.push_back(ptx);
  
     // add tx keys only to ptx
     txs.back().tx_key = tx_key;
     txs.back().additional_tx_keys = additional_tx_keys;
   }
  
   // add key image mapping for these txes
   const account_keys &keys = get_account().get_keys();
   hw::device &hwdev = m_account.get_device();
   for (size_t n = 0; n < exported_txs.txes.size(); ++n)
   {
     const cryptonote::transaction &tx = signed_txes.ptx[n].tx;
  
     crypto::key_derivation derivation;
     std::vector<crypto::key_derivation> additional_derivations;
  
     // compute public keys from out secret keys
     crypto::public_key tx_pub_key;
     crypto::secret_key_to_public_key(txs[n].tx_key, tx_pub_key);
     std::vector<crypto::public_key> additional_tx_pub_keys;
     for (const crypto::secret_key &skey: txs[n].additional_tx_keys)
     {
       additional_tx_pub_keys.resize(additional_tx_pub_keys.size() + 1);
       crypto::secret_key_to_public_key(skey, additional_tx_pub_keys.back());
     }
  
     // compute derivations
     hwdev.set_mode(hw::device::TRANSACTION_PARSE);
     if (!hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation))
     {
       MWARNING("Failed to generate key derivation from tx pubkey in " << cryptonote::get_transaction_hash(tx) << ", skipping");
       static_assert(sizeof(derivation) == sizeof(rct::key), "Mismatched sizes of key_derivation and rct::key");
       memcpy(&derivation, rct::identity().bytes, sizeof(derivation));
     }
     for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
     {
       additional_derivations.push_back({});
       if (!hwdev.generate_key_derivation(additional_tx_pub_keys[i], keys.m_view_secret_key, additional_derivations.back()))
       {
         MWARNING("Failed to generate key derivation from additional tx pubkey in " << cryptonote::get_transaction_hash(tx) << ", skipping");
         memcpy(&additional_derivations.back(), rct::identity().bytes, sizeof(crypto::key_derivation));
       }
     }
  
     for (size_t i = 0; i < tx.vout.size(); ++i)
     {
       if (tx.vout[i].target.type() != typeid(cryptonote::txout_to_key))
         continue;
       const cryptonote::txout_to_key &out = boost::get<cryptonote::txout_to_key>(tx.vout[i].target);
       // if this output is back to this wallet, we can calculate its key image already
       if (!is_out_to_acc_precomp(m_subaddresses, out.key, derivation, additional_derivations, i, hwdev))
         continue;
       crypto::key_image ki;
       cryptonote::keypair in_ephemeral;
       if (generate_key_image_helper(keys, m_subaddresses, out.key, tx_pub_key, additional_tx_pub_keys, i, in_ephemeral, ki, hwdev))
         signed_txes.tx_key_images[out.key] = ki;
       else
         MERROR("Failed to calculate key image");
     }
   }
  
   // add key images
   signed_txes.key_images.resize(m_transfers.size());
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     if (!m_transfers[i].m_key_image_known || m_transfers[i].m_key_image_partial)
       LOG_PRINT_L0("WARNING: key image not known in signing wallet at index " << i);
     signed_txes.key_images[i] = m_transfers[i].m_key_image;
   }
  
   return true;
 }

Here is the call graph for this function:

◆ sign_tx_dump_to_str()

std::string tools::wallet2::sign_tx_dump_to_str	(	unsigned_tx_set &	exported_txs,
		std::vector< wallet2::pending_tx > &	ptx,
		signed_tx_set &	signed_txes
	)

Definition at line 7094 of file wallet2.cpp.

 {
   // sign the transactions
   bool r = sign_tx(exported_txs, ptx, signed_txes);
   if (!r)
   {
     LOG_PRINT_L0("Failed to sign unsigned_tx_set");
     return std::string();
   }
  
   // save as binary
   std::ostringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   try
   {
     ar << signed_txes;
   }
   catch(...)
   {
     return std::string();
   }
   LOG_PRINT_L3("Saving signed tx data (with encryption): " << oss.str());
   std::string ciphertext = encrypt_with_view_secret_key(oss.str());
   return std::string(SIGNED_TX_PREFIX) + ciphertext;
 }

◆ stop()

void tools::wallet2::stop ( )

inline

Definition at line 754 of file wallet2.h.

754 { m_run.store(false, std::memory_order_relaxed); m_message_store.stop(); }

mms::message_store::stop

void stop()

Definition: message_store.h:280

◆ store()

void tools::wallet2::store ( )

Definition at line 5922 of file wallet2.cpp.

 {
   if (!m_wallet_file.empty())
     store_to("", epee::wipeable_string());
 }

Here is the caller graph for this function:

◆ store_to()

void tools::wallet2::store_to	(	const std::string &	path,
		const epee::wipeable_string &	password
	)

store_to Stores wallet to another file(s), deleting old ones

Parameters

path	Path to the wallet file (keys and address filenames will be generated based on this filename)
password	Password to protect new wallet (TODO: probably better save the password in the wallet object?)

Definition at line 5928 of file wallet2.cpp.

 {
   trim_hashchain();
  
   // if file is the same, we do:
   // 1. save wallet to the *.new file
   // 2. remove old wallet file
   // 3. rename *.new to wallet_name
  
   // handle if we want just store wallet state to current files (ex store() replacement);
   bool same_file = true;
   if (!path.empty())
   {
     std::string canonical_path = boost::filesystem::canonical(m_wallet_file).string();
     size_t pos = canonical_path.find(path);
     same_file = pos != std::string::npos;
   }
  
  
   if (!same_file)
   {
     // check if we want to store to directory which doesn't exists yet
     boost::filesystem::path parent_path = boost::filesystem::path(path).parent_path();
  
     // if path is not exists, try to create it
     if (!parent_path.empty() &&  !boost::filesystem::exists(parent_path))
     {
       boost::system::error_code ec;
       if (!boost::filesystem::create_directories(parent_path, ec))
       {
         throw std::logic_error(ec.message());
       }
     }
   }
   // preparing wallet data
   std::stringstream oss;
   boost::archive::portable_binary_oarchive ar(oss);
   ar << *this;
  
   wallet2::cache_file_data cache_file_data = boost::value_initialized<wallet2::cache_file_data>();
   cache_file_data.cache_data = oss.str();
   std::string cipher;
   cipher.resize(cache_file_data.cache_data.size());
   cache_file_data.iv = crypto::rand<crypto::chacha_iv>();
   crypto::chacha20(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), m_cache_key, cache_file_data.iv, &cipher[0]);
   cache_file_data.cache_data = cipher;
  
   const std::string new_file = same_file ? m_wallet_file + ".new" : path;
   const std::string old_file = m_wallet_file;
   const std::string old_keys_file = m_keys_file;
   const std::string old_address_file = m_wallet_file + ".address.txt";
   const std::string old_mms_file = m_mms_file;
  
   // save keys to the new file
   // if we here, main wallet file is saved and we only need to save keys and address files
   if (!same_file) {
     prepare_file_names(path);
     bool r = store_keys(m_keys_file, password, false);
     THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
     if (boost::filesystem::exists(old_address_file))
     {
       // save address to the new file
       const std::string address_file = m_wallet_file + ".address.txt";
       r = file_io_utils::save_string_to_file(address_file, m_account.get_public_address_str(m_nettype));
       THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_wallet_file);
     }
     // remove old wallet file
     r = boost::filesystem::remove(old_file);
     if (!r) {
       LOG_ERROR("error removing file: " << old_file);
     }
     // remove old keys file
     r = boost::filesystem::remove(old_keys_file);
     if (!r) {
       LOG_ERROR("error removing file: " << old_keys_file);
     }
     // remove old address file
     r = boost::filesystem::remove(old_address_file);
     if (!r) {
       LOG_ERROR("error removing file: " << old_address_file);
     }
     // remove old message store file
     if (boost::filesystem::exists(old_mms_file))
     {
       r = boost::filesystem::remove(old_mms_file);
       if (!r) {
         LOG_ERROR("error removing file: " << old_mms_file);
       }
     }
   } else {
     // save to new file
 #ifdef WIN32
     // On Windows avoid using std::ofstream which does not work with UTF-8 filenames
     // The price to pay is temporary higher memory consumption for string stream + binary archive
     std::ostringstream oss;
     binary_archive<true> oar(oss);
     bool success = ::serialization::serialize(oar, cache_file_data);
     if (success) {
         success = epee::file_io_utils::save_string_to_file(new_file, oss.str());
     }
     THROW_WALLET_EXCEPTION_IF(!success, error::file_save_error, new_file);
 #else
     std::ofstream ostr;
     ostr.open(new_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
     binary_archive<true> oar(ostr);
     bool success = ::serialization::serialize(oar, cache_file_data);
     ostr.close();
     THROW_WALLET_EXCEPTION_IF(!success || !ostr.good(), error::file_save_error, new_file);
 #endif
  
     // here we have "*.new" file, we need to rename it to be without ".new"
     std::error_code e = tools::replace_file(new_file, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(e, error::file_save_error, m_wallet_file, e);
   }
   
   if (m_message_store.get_active())
   {
     // While the "m_message_store" object of course always exist, a file for the message
     // store should only exist if the MMS is really active
     m_message_store.write_to_file(get_multisig_wallet_state(), m_mms_file);
   }
   
 }

Here is the call graph for this function:

◆ store_tx_info() [1/2]

bool tools::wallet2::store_tx_info ( ) const

inline

Definition at line 1061 of file wallet2.h.

1061 { return m_store_tx_info; }

◆ store_tx_info() [2/2]

void tools::wallet2::store_tx_info ( bool store )

inline

Definition at line 1062 of file wallet2.h.

1062 { m_store_tx_info = store; }

Here is the call graph for this function:

◆ synced_to_v10()

bool tools::wallet2::synced_to_v10 ( ) const

inline

Definition at line 891 of file wallet2.h.

891 {return nettype() == cryptonote::network_type::MAINNET ? get_blockchain_current_height() >= 1175315 : get_blockchain_current_height() >= 1165235;}

Here is the call graph for this function:

◆ thaw() [1/2]

void tools::wallet2::thaw ( const crypto::key_image & ki )

Definition at line 1609 of file wallet2.cpp.

 {
   thaw(get_transfer_details(ki));
 }

Here is the call graph for this function:

◆ thaw() [2/2]

void tools::wallet2::thaw ( size_t idx )

Definition at line 1590 of file wallet2.cpp.

 {
   CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "Invalid transfer_details index");
   transfer_details &td = m_transfers[idx];
   td.m_frozen = false;
 }

Here is the caller graph for this function:

◆ tr()

const char * tools::wallet2::tr ( const char * str )

static

Definition at line 993 of file wallet2.cpp.

993 { return i18n_translate(str, "tools::wallet2"); }

i18n_translate

const char * i18n_translate(const char *s, const std::string &context)

Definition: i18n.cpp:322

Here is the call graph for this function:

◆ track_uses() [1/2]

bool tools::wallet2::track_uses ( ) const

inline

Definition at line 1097 of file wallet2.h.

1097 { return m_track_uses; }

◆ track_uses() [2/2]

void tools::wallet2::track_uses ( bool value )

inline

Definition at line 1098 of file wallet2.h.

1098 { m_track_uses = value; }

◆ transfer_selected()

template<typename T >

void tools::wallet2::transfer_selected	(	const std::vector< cryptonote::tx_destination_entry > &	dsts,
		const std::vector< size_t > &	selected_transfers,
		size_t	fake_outputs_count,
		std::vector< std::vector< tools::wallet2::get_outs_entry >> &	outs,
		uint64_t	unlock_time,
		uint64_t	fee,
		const std::vector< uint8_t > &	extra,
		T	destination_split_strategy,
		const tx_dust_policy &	dust_policy,
		cryptonote::transaction &	tx,
		pending_tx &	ptx
	)

Definition at line 8742 of file wallet2.cpp.

 {
   using namespace cryptonote;
   // throw if attempting a transaction with no destinations
   THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
  
   THROW_WALLET_EXCEPTION_IF(m_multisig, error::wallet_internal_error, "Multisig wallets cannot spend non rct outputs");
  
   uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit();
   uint64_t needed_etn = fee;
   LOG_PRINT_L2("transfer: starting with fee " << print_etn (needed_etn));
  
   // calculate total amount being sent to all destinations
   // throw if total amount overflows uint64_t
   for(auto& dt: dsts)
   {
     THROW_WALLET_EXCEPTION_IF(0 == dt.amount, error::zero_destination);
     needed_etn += dt.amount;
     LOG_PRINT_L2("transfer: adding " << print_etn(dt.amount) << ", for a total of " << print_etn (needed_etn));
     THROW_WALLET_EXCEPTION_IF(needed_etn < dt.amount, error::tx_sum_overflow, dsts, fee, m_nettype);
   }
  
   uint64_t found_etn = 0;
   for(size_t idx: selected_transfers)
   {
     found_etn += m_transfers[idx].amount();
   }
  
   LOG_PRINT_L2("wanted " << print_etn(needed_etn) << ", found " << print_etn(found_etn) << ", fee " << print_etn(fee));
   THROW_WALLET_EXCEPTION_IF(found_etn < needed_etn, error::not_enough_unlocked_etn, found_etn, needed_etn - fee, fee);
  
   uint32_t subaddr_account = m_transfers[*selected_transfers.begin()].m_subaddr_index.major;
   for (auto i = ++selected_transfers.begin(); i != selected_transfers.end(); ++i)
     THROW_WALLET_EXCEPTION_IF(subaddr_account != m_transfers[*i].m_subaddr_index.major, error::wallet_internal_error, "the tx uses funds from multiple accounts");
  
   if (outs.empty())
     get_outs(outs, selected_transfers, fake_outputs_count, tx.version); // may throw
  
   //prepare inputs
   LOG_PRINT_L2("preparing outputs");
   typedef cryptonote::tx_source_entry::output_entry tx_output_entry;
   size_t i = 0, out_index = 0;
   std::vector<cryptonote::tx_source_entry> sources;
   for(size_t idx: selected_transfers)
   {
     sources.resize(sources.size()+1);
     cryptonote::tx_source_entry& src = sources.back();
     const transfer_details& td = m_transfers[idx];
     src.amount = td.amount();
     src.rct = td.is_rct();
     if(tx.version < 3) {
         //paste keys (fake and real)
         // adding pairs of global index & stealth address to our vector of source outs (needed forold ins only)
         for (size_t n = 0; n < fake_outputs_count + 1; ++n) {
             tx_output_entry oe;
             oe.first = std::get<0>(outs[out_index][n]);
             oe.second.dest = rct::pk2rct(std::get<1>(outs[out_index][n]));
             oe.second.mask = std::get<2>(outs[out_index][n]);
  
             src.outputs.push_back(oe);
             ++i;
         }
  
         //paste real transaction to the random index
         auto it_to_replace = std::find_if(src.outputs.begin(), src.outputs.end(), [&](const tx_output_entry &a) {
             return a.first == td.m_global_output_index;
         });
         THROW_WALLET_EXCEPTION_IF(it_to_replace == src.outputs.end(), error::wallet_internal_error,
                                   "real output not found");
  
         tx_output_entry real_oe;
         real_oe.first = td.m_global_output_index;
         real_oe.second.dest = rct::pk2rct(
                 boost::get<txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key);
         real_oe.second.mask = rct::commit(td.amount(), td.m_mask);
         *it_to_replace = real_oe;
         src.real_out_tx_key = get_tx_pub_key_from_extra(td.m_tx, td.m_pk_index);
         src.real_out_additional_tx_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
         src.real_output = it_to_replace - src.outputs.begin();
         src.multisig_kLRki = rct::multisig_kLRki({rct::zero(), rct::zero(), rct::zero(), rct::zero()});
     }
     src.real_output_in_tx_index = td.m_internal_output_index; // these two are all we really need for v3 sources
     src.tx_hash = td.m_txid;
     src.subaddr_index = td.m_subaddr_index;
     detail::print_source_entry(src);
     ++out_index;
   }
   LOG_PRINT_L2("outputs prepared");
  
   cryptonote::tx_destination_entry change_dts = AUTO_VAL_INIT(change_dts);
   if (needed_etn < found_etn)
   {
     // send change to the first input's address for v3+ tx
     uint32_t change_subaddress_minor = tx.version > 2 ? sources.front().subaddr_index.minor : 0;
     change_dts.addr = get_subaddress({subaddr_account, change_subaddress_minor});
     change_dts.is_subaddress = (subaddr_account != 0 || change_subaddress_minor != 0);
     change_dts.amount = found_etn - needed_etn;
   }
  
   std::vector<cryptonote::tx_destination_entry> splitted_dsts, dust_dsts;
   uint64_t dust = 0;
   destination_split_strategy(dsts, change_dts, dust_policy.dust_threshold, splitted_dsts, dust_dsts);
   for(auto& d: dust_dsts) {
     THROW_WALLET_EXCEPTION_IF(dust_policy.dust_threshold < d.amount, error::wallet_internal_error, "invalid dust value: dust = " +
       std::to_string(d.amount) + ", dust_threshold = " + std::to_string(dust_policy.dust_threshold));
   }
   for(auto& d: dust_dsts) {
     if (!dust_policy.add_to_fee)
       splitted_dsts.push_back(cryptonote::tx_destination_entry(d.amount, dust_policy.addr_for_dust, d.is_subaddress));
     dust += d.amount;
   }
  
   crypto::secret_key tx_key;
   std::vector<crypto::secret_key> additional_tx_keys;
   rct::multisig_out msout;
  
   LOG_PRINT_L2("constructing tx");
   bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sources, splitted_dsts, change_dts.addr, extra, tx, unlock_time, tx_key, additional_tx_keys, false, {}, m_multisig ? &msout : NULL, m_account_major_offset, this->m_nettype);
   LOG_PRINT_L2("constructed tx, r="<<r);
   THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time, m_nettype);
   THROW_WALLET_EXCEPTION_IF(upper_transaction_weight_limit <= get_transaction_weight(tx), error::tx_too_big, tx, upper_transaction_weight_limit);
  
   std::string key_images;
   bool are_ins_correct_type = tx.version >= 3 ?
                                   std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
                                   {
                                       CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key_public, in, false);
                                       return true;
                                   })
                                   :
                                   std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
                                   {
                                       CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
                                       key_images += boost::to_string(in.k_image) + " ";
                                       return true;
                                   });
  
   THROW_WALLET_EXCEPTION_IF(!are_ins_correct_type, error::unexpected_txin_type, tx);
   
   
   bool dust_sent_elsewhere = (dust_policy.addr_for_dust.m_view_public_key != change_dts.addr.m_view_public_key
                                 || dust_policy.addr_for_dust.m_spend_public_key != change_dts.addr.m_spend_public_key);
   
   if (dust_policy.add_to_fee || dust_sent_elsewhere) change_dts.amount -= dust;
  
   ptx.key_images = key_images;
   ptx.fee = (dust_policy.add_to_fee ? fee+dust : fee);
   ptx.dust = ((dust_policy.add_to_fee || dust_sent_elsewhere) ? dust : 0);
   ptx.dust_added_to_fee = dust_policy.add_to_fee;
   ptx.tx = tx;
   ptx.change_dts = change_dts;
   ptx.selected_transfers = selected_transfers;
   ptx.tx_key = tx_key;
   ptx.additional_tx_keys = additional_tx_keys;
   ptx.dests = dsts;
   ptx.construction_data.sources = sources;
   ptx.construction_data.change_dts = change_dts;
   ptx.construction_data.splitted_dsts = splitted_dsts;
   ptx.construction_data.selected_transfers = selected_transfers;
   ptx.construction_data.extra = tx.extra;
   ptx.construction_data.unlock_time = unlock_time;
   ptx.construction_data.use_rct = false;
   ptx.construction_data.rct_config = { rct::RangeProofBorromean, 0 };
   ptx.construction_data.dests = dsts;
   // record which subaddress indices are being used as inputs
   ptx.construction_data.subaddr_account = subaddr_account;
   ptx.construction_data.subaddr_indices.clear();
   for (size_t idx: selected_transfers)
     ptx.construction_data.subaddr_indices.insert(m_transfers[idx].m_subaddr_index.minor);
   LOG_PRINT_L2("transfer_selected done");
 }

Here is the call graph for this function:

◆ unblackball_output()

bool tools::wallet2::unblackball_output ( const std::pair< uint64_t, uint64_t > & output )

Definition at line 7988 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
   try { return m_ringdb->unblackball(output); }
   catch (const std::exception &e) { return false; }
 }

◆ unlock_keys_file()

bool tools::wallet2::unlock_keys_file ( )

Definition at line 8015 of file wallet2.cpp.

 {
   if (!m_keys_file_locker)
   {
     MDEBUG(m_keys_file << " is already unlocked.");
     return false;
   }
   m_keys_file_locker.reset();
   return true;
 }

◆ unlocked_balance()

uint64_t tools::wallet2::unlocked_balance	(	uint32_t	subaddr_index_major,
		bool	public_blockchain,
		uint64_t *	blocks_to_unlock = `NULL`
	)		const

Definition at line 6062 of file wallet2.cpp.

 {
   uint64_t amount = 0;
   if (blocks_to_unlock)
     *blocks_to_unlock = 0;
   if(m_light_wallet)
     return m_light_wallet_balance;
   for (const auto& i : unlocked_balance_per_subaddress(index_major, public_blockchain))
   {
     amount += i.second.first;
     if (blocks_to_unlock && i.second.second > *blocks_to_unlock)
       *blocks_to_unlock = i.second.second;
   }
   return amount;
 }

Here is the caller graph for this function:

◆ unlocked_balance_all()

uint64_t tools::wallet2::unlocked_balance_all	(	bool	public_blockchain,
		uint64_t *	blocks_to_unlock = `NULL`
	)		const

Definition at line 6190 of file wallet2.cpp.

 {
   uint64_t r = 0;
   if (blocks_to_unlock)
     *blocks_to_unlock = 0;
   for (uint32_t index_major = 0; index_major < get_num_subaddress_accounts(); ++index_major)
   {
     uint64_t local_blocks_to_unlock;
     r += unlocked_balance(index_major, public_blockchain ,blocks_to_unlock ? &local_blocks_to_unlock : NULL);
     if (blocks_to_unlock)
       *blocks_to_unlock = std::max(*blocks_to_unlock, local_blocks_to_unlock);
   }
   return r;
 }

◆ unlocked_balance_per_subaddress()

std::map< uint32_t, std::pair< uint64_t, uint64_t > > tools::wallet2::unlocked_balance_per_subaddress	(	uint32_t	subaddr_index_major,
		bool	public_blockchain = `false`
	)		const

Definition at line 6139 of file wallet2.cpp.

 {
   std::map<uint32_t, std::pair<uint64_t, uint64_t>> amount_per_subaddr; //map of subaddr minor index : <amount,unlock t>
   const uint64_t blockchain_height = get_blockchain_current_height();
   //Figure out amount & blocks_to_unlock for the major subaddress index for each transfer
   for(const transfer_details& td: m_transfers)
   {
     if((public_blockchain && td.m_tx.version == 1) || (!public_blockchain && td.m_tx.version > 1))
       continue;
  
     if(td.m_subaddr_index.major == index_major && !td.m_spent && !td.m_frozen)
     {
       uint64_t amount = 0, blocks_to_unlock = 0;
       if (is_transfer_unlocked(td))
       {
         amount = td.amount();
         blocks_to_unlock = 0;
       }
       else
       {
  
         uint64_t v8height = m_nettype == TESTNET ? 446674 : 589169;
         uint16_t UNLOCK_WINDOW = td.m_block_height > v8height ? ETN_DEFAULT_TX_SPENDABLE_AGE_V8 : CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE;
         uint64_t unlock_height = td.m_block_height + std::max<uint64_t>(UNLOCK_WINDOW, CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS);
         if (td.m_tx.unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER && td.m_tx.unlock_time > unlock_height)
           unlock_height = td.m_tx.unlock_time;
         blocks_to_unlock = unlock_height > blockchain_height ? unlock_height - blockchain_height : 0;
         amount = 0;
       }
       auto found = amount_per_subaddr.find(td.m_subaddr_index.minor);
       // if we don't have this subaddress index (key) in our map, create a new entry, otherwise just add a new pair
       if (found == amount_per_subaddr.end())
         amount_per_subaddr[td.m_subaddr_index.minor] = std::make_pair(amount, blocks_to_unlock);
       else
       {
         found->second.first += amount;
         found->second.second = std::max(found->second.second, blocks_to_unlock);
       }
     }
   }
   return amount_per_subaddr;
 }

◆ unset_ring() [1/2]

bool tools::wallet2::unset_ring ( const crypto::hash & txid )

Definition at line 7871 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
  
   COMMAND_RPC_GET_TRANSACTIONS::request req;
   COMMAND_RPC_GET_TRANSACTIONS::response res;
   req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
   req.decode_as_json = false;
   req.prune = true;
   m_daemon_rpc_mutex.lock();
   bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to get transaction from daemon");
   if (res.txs.empty())
     return false;
   THROW_WALLET_EXCEPTION_IF(res.txs.size(), error::wallet_internal_error, "Failed to get transaction from daemon");
  
   cryptonote::transaction tx;
   crypto::hash tx_hash;
   if (!get_pruned_tx(res.txs.front(), tx, tx_hash))
     return false;
   THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
  
   try { return m_ringdb->remove_rings(get_ringdb_key(), tx); }
   catch (const std::exception &e) { return false; }
 }

Here is the call graph for this function:

◆ unset_ring() [2/2]

bool tools::wallet2::unset_ring ( const std::vector< crypto::key_image > & key_images )

Definition at line 7862 of file wallet2.cpp.

 {
   if (!m_ringdb)
     return false;
  
   try { return m_ringdb->remove_rings(get_ringdb_key(), key_images); }
   catch (const std::exception &e) { return false; }
 }

◆ update_pool_state()

void tools::wallet2::update_pool_state ( bool refreshed = false )

Definition at line 3147 of file wallet2.cpp.

 {
   MTRACE("update_pool_state start");
  
   auto keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this]() {
     if (m_encrypt_keys_after_refresh)
     {
       encrypt_keys(*m_encrypt_keys_after_refresh);
       m_encrypt_keys_after_refresh = boost::none;
     }
   });
  
   // get the pool state
   cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::request req;
   cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::response res;
   m_daemon_rpc_mutex.lock();
   bool r = invoke_http_json("/get_transaction_pool_hashes.bin", req, res, rpc_timeout);
   m_daemon_rpc_mutex.unlock();
   THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_transaction_pool_hashes.bin");
   THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_transaction_pool_hashes.bin");
   THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::get_tx_pool_error);
   MTRACE("update_pool_state got pool");
  
   // remove any pending tx that's not in the pool
   std::unordered_map<crypto::hash, wallet2::unconfirmed_transfer_details>::iterator it = m_unconfirmed_txs.begin();
   while (it != m_unconfirmed_txs.end())
   {
     const crypto::hash &txid = it->first;
     bool found = false;
     for (const auto &it2: res.tx_hashes)
     {
       if (it2 == txid)
       {
         found = true;
         break;
       }
     }
     auto pit = it++;
     if (!found)
     {
       // we want to avoid a false positive when we ask for the pool just after
       // a tx is removed from the pool due to being found in a new block, but
       // just before the block is visible by refresh. So we keep a boolean, so
       // that the first time we don't see the tx, we set that boolean, and only
       // delete it the second time it is checked (but only when refreshed, so
       // we're sure we've seen the blockchain state first)
       if (pit->second.m_state == wallet2::unconfirmed_transfer_details::pending)
       {
         LOG_PRINT_L1("Pending txid " << txid << " not in pool, marking as not in pool");
         pit->second.m_state = wallet2::unconfirmed_transfer_details::pending_not_in_pool;
       }
       else if (pit->second.m_state == wallet2::unconfirmed_transfer_details::pending_not_in_pool && refreshed)
       {
         LOG_PRINT_L1("Pending txid " << txid << " not in pool, marking as failed");
         pit->second.m_state = wallet2::unconfirmed_transfer_details::failed;
  
         // the inputs aren't spent anymore, since the tx failed
         remove_rings(pit->second.m_tx);
         for (size_t vini = 0; vini < pit->second.m_tx.vin.size(); ++vini)
         {
           if (pit->second.m_tx.vin[vini].type() == typeid(txin_to_key))
           {
             txin_to_key &tx_in_to_key = boost::get<txin_to_key>(pit->second.m_tx.vin[vini]);
             for (size_t i = 0; i < m_transfers.size(); ++i)
             {
               const transfer_details &td = m_transfers[i];
               if (td.m_key_image == tx_in_to_key.k_image)
               {
                  LOG_PRINT_L1("Resetting spent status for output " << vini << ": " << td.m_key_image);
                  set_unspent(i);
                  break;
               }
             }
           }
         }
       }
     }
   }
   MTRACE("update_pool_state done first loop");
  
   // remove pool txes to us that aren't in the pool anymore
   // but only if we just refreshed, so that the tx can go in
   // the in transfers list instead (or nowhere if it just
   // disappeared without being mined)
   if (refreshed)
     remove_obsolete_pool_txs(res.tx_hashes);
  
   MTRACE("update_pool_state done second loop");
  
   // gather txids of new pool txes to us
   std::vector<std::pair<crypto::hash, bool>> txids;
   for (const auto &txid: res.tx_hashes)
   {
     bool txid_found_in_up = false;
     for (const auto &up: m_unconfirmed_payments)
     {
       if (up.second.m_pd.m_tx_hash == txid)
       {
         txid_found_in_up = true;
         break;
       }
     }
     if (m_scanned_pool_txs[0].find(txid) != m_scanned_pool_txs[0].end() || m_scanned_pool_txs[1].find(txid) != m_scanned_pool_txs[1].end())
     {
       // if it's for us, we want to keep track of whether we saw a double spend, so don't bail out
       if (!txid_found_in_up)
       {
         LOG_PRINT_L2("Already seen " << txid << ", and not for us, skipped");
         continue;
       }
     }
     if (!txid_found_in_up)
     {
       LOG_PRINT_L1("Found new pool tx: " << txid);
       bool found = false;
       for (const auto &i: m_unconfirmed_txs)
       {
         if (i.first == txid)
         {
           found = true;
           // if this is a payment to yourself at a different subaddress account, don't skip it
           // so that you can see the incoming pool tx with 'show_transfers' on that receiving subaddress account
           const unconfirmed_transfer_details& utd = i.second;
           for (const auto& dst : utd.m_dests)
           {
             auto subaddr_index = m_subaddresses.find(dst.addr.m_spend_public_key);
             if (subaddr_index != m_subaddresses.end() && subaddr_index->second.major != utd.m_subaddr_account)
             {
               found = false;
               break;
             }
           }
           break;
         }
       }
       if (!found)
       {
         // not one of those we sent ourselves
         txids.push_back({txid, false});
       }
       else
       {
         LOG_PRINT_L1("We sent that one");
       }
     }
     else
     {
       LOG_PRINT_L1("Already saw that one, it's for us");
       txids.push_back({txid, true});
     }
   }
  
   // get those txes
   if (!txids.empty())
   {
     cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request req;
     cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response res;
     for (const auto &p: txids)
       req.txs_hashes.push_back(epee::string_tools::pod_to_hex(p.first));
     MDEBUG("asking for " << txids.size() << " transactions");
     req.decode_as_json = false;
     req.prune = true;
     m_daemon_rpc_mutex.lock();
     bool r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     MDEBUG("Got " << r << " and " << res.status);
     if (r && res.status == CORE_RPC_STATUS_OK)
     {
       if (res.txs.size() == txids.size())
       {
         for (const auto &tx_entry: res.txs)
         {
           if (tx_entry.in_pool)
           {
             cryptonote::transaction tx;
             cryptonote::blobdata bd;
             crypto::hash tx_hash;
  
             if (get_pruned_tx(tx_entry, tx, tx_hash))
             {
                 const std::vector<std::pair<crypto::hash, bool>>::const_iterator i = std::find_if(txids.begin(), txids.end(),
                     [tx_hash](const std::pair<crypto::hash, bool> &e) { return e.first == tx_hash; });
                 if (i != txids.end())
                 {
                   process_new_transaction(tx_hash, tx, std::vector<uint64_t>(), 0, time(NULL), false, true, tx_entry.double_spend_seen, false, {});
                   m_scanned_pool_txs[0].insert(tx_hash);
                   if (m_scanned_pool_txs[0].size() > 5000)
                   {
                     std::swap(m_scanned_pool_txs[0], m_scanned_pool_txs[1]);
                     m_scanned_pool_txs[0].clear();
                   }
                 }
                 else
                 {
                   MERROR("Got txid " << tx_hash << " which we did not ask for");
                 }
             }
             else
             {
               LOG_PRINT_L0("Failed to parse transaction from daemon");
             }
           }
           else
           {
             LOG_PRINT_L1("Transaction from daemon was in pool, but is no more");
           }
         }
       }
       else
       {
         LOG_PRINT_L0("Expected " << txids.size() << " tx(es), got " << res.txs.size());
       }
     }
     else
     {
       LOG_PRINT_L0("Error calling gettransactions daemon RPC: r " << r << ", status " << get_rpc_status(res.status));
     }
   }
   MTRACE("update_pool_state end");
 }

Here is the call graph for this function:

◆ use_fork_rules()

bool tools::wallet2::use_fork_rules	(	uint8_t	version,
		int64_t	early_blocks = `0`
	)		const

Definition at line 10510 of file wallet2.cpp.

 {
   // TODO: How to get fork rule info from light wallet node?
   if(m_light_wallet)
     return true;
   uint64_t height, earliest_height;
   boost::optional<std::string> result = m_node_rpc_proxy.get_height(height);
   throw_on_rpc_response_error(result, "get_info");
   result = m_node_rpc_proxy.get_earliest_height(version, earliest_height);
   throw_on_rpc_response_error(result, "get_hard_fork_info");
  
   bool close_enough = (int64_t)height >= (int64_t)earliest_height - early_blocks && earliest_height != std::numeric_limits<uint64_t>::max() && version <= CURRENT_HARDFORK_VERSION; // start using the rules that many blocks beforehand
   if (close_enough)
     LOG_PRINT_L2("Using v" << (unsigned)version << " rules");
   else
     LOG_PRINT_L2("Not using v" << (unsigned)version << " rules");
   return close_enough;
 }

◆ verify()

bool tools::wallet2::verify	(	const std::string &	data,
		const cryptonote::account_public_address &	address,
		const std::string &	signature
	)		const

Definition at line 11876 of file wallet2.cpp.

 {
   const size_t header_len = strlen("SigV1");
   if (signature.size() < header_len || signature.substr(0, header_len) != "SigV1") {
     LOG_PRINT_L0("Signature header check error");
     return false;
   }
   crypto::hash hash;
   crypto::cn_fast_hash(data.data(), data.size(), hash);
   std::string decoded;
   if (!tools::base58::decode(signature.substr(header_len), decoded)) {
     LOG_PRINT_L0("Signature decoding error");
     return false;
   }
   crypto::signature s;
   if (sizeof(s) != decoded.size()) {
     LOG_PRINT_L0("Signature decoding error");
     return false;
   }
   memcpy(&s, decoded.data(), sizeof(s));
   return crypto::check_signature(hash, address.m_spend_public_key, s);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_extra_multisig_info()

bool tools::wallet2::verify_extra_multisig_info	(	const std::string &	data,
		std::unordered_set< crypto::public_key > &	pkeys,
		crypto::public_key &	signer
	)

static

Verifies and extracts keys from a packaged multisig information string

Definition at line 5476 of file wallet2.cpp.

 {
   if (data.size() < MULTISIG_EXTRA_INFO_MAGIC.size() || data.substr(0, MULTISIG_EXTRA_INFO_MAGIC.size()) != MULTISIG_EXTRA_INFO_MAGIC)
   {
     MERROR("Multisig info header check error");
     return false;
   }
   std::string decoded;
   if (!tools::base58::decode(data.substr(MULTISIG_EXTRA_INFO_MAGIC.size()), decoded))
   {
     MERROR("Multisig info decoding error");
     return false;
   }
   if (decoded.size() < sizeof(crypto::public_key) + sizeof(crypto::signature))
   {
     MERROR("Multisig info is corrupt");
     return false;
   }
   if ((decoded.size() - (sizeof(crypto::public_key) + sizeof(crypto::signature))) % sizeof(crypto::public_key))
   {
     MERROR("Multisig info is corrupt");
     return false;
   }
  
   const size_t n_keys = (decoded.size() - (sizeof(crypto::public_key) + sizeof(crypto::signature))) / sizeof(crypto::public_key);
   size_t offset = 0;
   signer = *(const crypto::public_key*)(decoded.data() + offset);
   offset += sizeof(signer);
   const crypto::signature &signature = *(const crypto::signature*)(decoded.data() + offset + n_keys * sizeof(crypto::public_key));
  
   crypto::hash hash;
   crypto::cn_fast_hash(decoded.data(), decoded.size() - sizeof(signature), hash);
   if (!crypto::check_signature(hash, signer, signature))
   {
     MERROR("Multisig info signature is invalid");
     return false;
   }
  
   for (size_t n = 0; n < n_keys; ++n)
   {
     crypto::public_key mspk = *(const crypto::public_key*)(decoded.data() + offset);
     pkeys.insert(mspk);
     offset += sizeof(mspk);
   }
  
   return true;
 }

◆ verify_multisig_info()

bool tools::wallet2::verify_multisig_info	(	const std::string &	data,
		crypto::secret_key &	skey,
		crypto::public_key &	pkey
	)

static

Verifies and extracts keys from a packaged multisig information string

Definition at line 5438 of file wallet2.cpp.

 {
   const size_t header_len = strlen("MultisigV1");
   if (data.size() < header_len || data.substr(0, header_len) != "MultisigV1")
   {
     MERROR("Multisig info header check error");
     return false;
   }
   std::string decoded;
   if (!tools::base58::decode(data.substr(header_len), decoded))
   {
     MERROR("Multisig info decoding error");
     return false;
   }
   if (decoded.size() != sizeof(crypto::secret_key) + sizeof(crypto::public_key) + sizeof(crypto::signature))
   {
     MERROR("Multisig info is corrupt");
     return false;
   }
  
   size_t offset = 0;
   skey = *(const crypto::secret_key*)(decoded.data() + offset);
   offset += sizeof(skey);
   pkey = *(const crypto::public_key*)(decoded.data() + offset);
   offset += sizeof(pkey);
   const crypto::signature &signature = *(const crypto::signature*)(decoded.data() + offset);
  
   crypto::hash hash;
   crypto::cn_fast_hash(decoded.data(), decoded.size() - sizeof(signature), hash);
   if (!crypto::check_signature(hash, pkey, signature))
   {
     MERROR("Multisig info signature is invalid");
     return false;
   }
  
   return true;
 }

Here is the call graph for this function:

◆ verify_password() [1/2]

bool tools::wallet2::verify_password ( const epee::wipeable_string & password )

verifies given password is correct for default wallet keys file

verify password for default wallet keys file.

Parameters

password Password to verify

Returns: true if password is correct

for verification only should not mutate state, unlike load_keys() can be used prior to rewriting wallet keys file, to ensure user has entered the correct password

Definition at line 4567 of file wallet2.cpp.

 {
   // this temporary unlocking is necessary for Windows (otherwise the file couldn't be loaded).
   unlock_keys_file();
   bool r = verify_password(m_keys_file, password, m_account.get_device().device_protocol() == hw::device::PROTOCOL_COLD || m_watch_only || m_multisig, m_account.get_device(), m_kdf_rounds);
   lock_keys_file();
   return r;
 }

◆ verify_password() [2/2]

bool tools::wallet2::verify_password	(	const std::string &	keys_file_name,
		const epee::wipeable_string &	password,
		bool	no_spend_key,
		hw::device &	hwdev,
		uint64_t	kdf_rounds
	)

static

verify password for specified wallet keys file.

Parameters

keys_file_name	Keys file to verify password for
password	Password to verify
no_spend_key	If set = only verify view keys, otherwise also spend keys
hwdev	The hardware device to use

Returns: true if password is correct

for verification only should not mutate state, unlike load_keys() can be used prior to rewriting wallet keys file, to ensure user has entered the correct password

Definition at line 4589 of file wallet2.cpp.

 {
   rapidjson::Document json;
   wallet2::keys_file_data keys_file_data;
   std::string buf;
   bool encrypted_secret_keys = false;
   bool r = epee::file_io_utils::load_file_to_string(keys_file_name, buf);
   THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, keys_file_name);
  
   // Decrypt the contents
   r = ::serialization::parse_binary(buf, keys_file_data);
   THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + keys_file_name + '\"');
   crypto::chacha_key key;
   crypto::generate_chacha_key(password.data(), password.size(), key, kdf_rounds);
   std::string account_data;
   account_data.resize(keys_file_data.account_data.size());
   crypto::chacha20(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
   if (json.Parse(account_data.c_str()).HasParseError() || !json.IsObject())
     crypto::chacha8(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
  
   // The contents should be JSON if the wallet follows the new format.
   if (json.Parse(account_data.c_str()).HasParseError())
   {
     // old format before JSON wallet key file format
   }
   else
   {
     account_data = std::string(json["key_data"].GetString(), json["key_data"].GetString() +
       json["key_data"].GetStringLength());
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, encrypted_secret_keys, uint32_t, Uint, false, false);
     encrypted_secret_keys = field_encrypted_secret_keys;
   }
  
   cryptonote::account_base account_data_check;
  
   r = epee::serialization::load_t_from_binary(account_data_check, account_data);
  
   if (encrypted_secret_keys)
     account_data_check.decrypt_keys(key);
  
   const cryptonote::account_keys& keys = account_data_check.get_keys();
   r = r && hwdev.verify_keys(keys.m_view_secret_key,  keys.m_account_address.m_view_public_key);
   if(!no_spend_key)
     r = r && hwdev.verify_keys(keys.m_spend_secret_key, keys.m_account_address.m_spend_public_key);
   return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_with_public_key()

bool tools::wallet2::verify_with_public_key	(	const std::string &	data,
		const crypto::public_key &	public_key,
		const std::string &	signature
	)		const

verify_with_public_key verifies message was signed with given public key

Parameters

data	message
public_key	public key to check signature
signature	signature of the message

Returns: true if the signature is correct

Definition at line 11911 of file wallet2.cpp.

 {
   if (signature.size() < MULTISIG_SIGNATURE_MAGIC.size() || signature.substr(0, MULTISIG_SIGNATURE_MAGIC.size()) != MULTISIG_SIGNATURE_MAGIC) {
     MERROR("Signature header check error");
     return false;
   }
   crypto::hash hash;
   crypto::cn_fast_hash(data.data(), data.size(), hash);
   std::string decoded;
   if (!tools::base58::decode(signature.substr(MULTISIG_SIGNATURE_MAGIC.size()), decoded)) {
     MERROR("Signature decoding error");
     return false;
   }
   crypto::signature s;
   if (sizeof(s) != decoded.size()) {
     MERROR("Signature decoding error");
     return false;
   }
   memcpy(&s, decoded.data(), sizeof(s));
   return crypto::check_signature(hash, public_key, s);
 }

◆ wallet_exists()

void tools::wallet2::wallet_exists	(	const std::string &	file_path,
		bool &	keys_file_exists,
		bool &	wallet_file_exists
	)

static

Check if wallet keys and bin files exist.

Parameters

file_path	Wallet file path
keys_file_exists	Whether keys file exists
wallet_file_exists	Whether bin file exists

Definition at line 5587 of file wallet2.cpp.

 {
   std::string keys_file, wallet_file, mms_file;
   do_prepare_file_names(file_path, keys_file, wallet_file, mms_file);
  
   boost::system::error_code ignore;
   keys_file_exists = boost::filesystem::exists(keys_file, ignore);
   wallet_file_exists = boost::filesystem::exists(wallet_file, ignore);
 }

Here is the caller graph for this function:

◆ wallet_valid_path_format()

bool tools::wallet2::wallet_valid_path_format ( const std::string & file_path )

static

Definition at line 5597 of file wallet2.cpp.

 {
   return !file_path.empty();
 }

◆ watch_only()

bool tools::wallet2::watch_only ( ) const

inline

Definition at line 819 of file wallet2.h.

819 { return m_watch_only; }

Here is the caller graph for this function:

◆ write_watch_only_wallet()

void tools::wallet2::write_watch_only_wallet	(	const std::string &	wallet_name,
		const epee::wipeable_string &	password,
		std::string &	new_keys_filename
	)

Writes to a file named based on the normal wallet (doesn't generate key, assumes it's already there)

Parameters

wallet_name	Base name of wallet file
password	Password for wallet file
new_keys_filename	[OUT] Name of new keys file

Definition at line 5576 of file wallet2.cpp.

 {
   prepare_file_names(wallet_name);
   boost::system::error_code ignored_ec;
   new_keys_filename = m_wallet_file + "-watchonly.keys";
   bool watch_only_keys_file_exists = boost::filesystem::exists(new_keys_filename, ignored_ec);
   THROW_WALLET_EXCEPTION_IF(watch_only_keys_file_exists, error::file_save_error, new_keys_filename);
   bool r = store_keys(new_keys_filename, password, true);
   THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, new_keys_filename);
 }

Friends And Related Function Documentation

◆ ::Serialization_portability_wallet_Test

friend class ::Serialization_portability_wallet_Test

friend

Definition at line 211 of file wallet2.h.

◆ ::wallet_accessor_test

friend class ::wallet_accessor_test

friend

Definition at line 212 of file wallet2.h.

◆ wallet_device_callback

friend class wallet_device_callback

friend

Definition at line 214 of file wallet2.h.

◆ wallet_keys_unlocker

friend class wallet_keys_unlocker

friend

Definition at line 213 of file wallet2.h.

Member Data Documentation

◆ ATTRIBUTE_DESCRIPTION

const char* const tools::wallet2::ATTRIBUTE_DESCRIPTION = "wallet2.description"

Definition at line 1301 of file wallet2.h.

◆ rpc_timeout

constexpr const std::chrono::seconds tools::wallet2::rpc_timeout = std::chrono::minutes(3) + std::chrono::seconds(30)

staticconstexpr

Definition at line 216 of file wallet2.h.

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ get_outs_entry

◆ payment_container

◆ transfer_container

Member Enumeration Documentation

◆ AskPasswordType

◆ BackgroundMiningSetupType

◆ RefreshType

Constructor & Destructor Documentation

◆ wallet2()

◆ ~wallet2()

Member Function Documentation

◆ account_major_offset() [1/2]

◆ account_major_offset() [2/2]

◆ add_address_book_row()

◆ add_checkpoint()

◆ add_subaddress()

◆ add_subaddress_account()

◆ adjust_mixin()

◆ adjust_priority()

◆ always_confirm_transfers() [1/2]

◆ always_confirm_transfers() [2/2]

◆ ask_password() [1/2]

◆ ask_password() [2/2]

◆ auto_low_priority() [1/2]

◆ auto_low_priority() [2/2]

◆ auto_refresh() [1/2]

◆ auto_refresh() [2/2]

◆ balance()

◆ balance_all()

◆ balance_per_subaddress()

◆ blackball_output()

◆ callback() [1/2]

◆ callback() [2/2]

◆ change_password()

◆ check_connection()

◆ check_reserve_proof()

◆ check_spend_proof()

◆ check_tx_key()

◆ check_tx_key_helper() [1/2]

◆ check_tx_key_helper() [2/2]

◆ check_tx_proof() [1/2]

◆ check_tx_proof() [2/2]

◆ cold_key_image_sync()

◆ cold_sign_tx()

◆ cold_tx_aux_import()

◆ commit_tx() [1/2]

◆ commit_tx() [2/2]

◆ confirm_backlog() [1/2]

◆ confirm_backlog() [2/2]

◆ confirm_export_overwrite() [1/2]

◆ confirm_export_overwrite() [2/2]

◆ confirm_missing_payment_id() [1/2]

◆ confirm_missing_payment_id() [2/2]

◆ confirm_non_default_ring_size() [1/2]

◆ confirm_non_default_ring_size() [2/2]

◆ create_transactions_2()

◆ create_transactions_all()

◆ create_transactions_from()

◆ create_transactions_single()

◆ create_unmixable_sweep_transactions()

◆ decrypt()

◆ decrypt_keys() [1/2]

◆ decrypt_keys() [2/2]

◆ decrypt_with_view_secret_key()

◆ default_mixin() [1/2]

◆ default_mixin() [2/2]

◆ deinit()

◆ delete_address_book_row()

◆ device_derivation_path() [1/2]

◆ device_derivation_path() [2/2]

◆ device_derivation_path_option()