tools::wallet2 Class Reference

#include <wallet2.h>

Classes
struct	multisig_info
struct	tx_scan_info_t
struct	transfer_details
struct	payment_details
struct	address_tx
struct	pool_payment_details
struct	unconfirmed_transfer_details
struct	confirmed_transfer_details
struct	tx_construction_data
struct	multisig_sig
struct	pending_tx
struct	unsigned_tx_set
struct	signed_tx_set
struct	multisig_tx_set
struct	keys_file_data
struct	cache_file_data
struct	address_book_row
struct	reserve_proof_entry
struct	parsed_block
struct	is_out_data
struct	tx_cache_data

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.
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.
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.
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.
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.
std::string	make_multisig (const epee::wipeable_string &password, const std::vector< std::string > &info, uint32_t threshold)
	Creates a multisig wallet.
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.
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.
bool	finalize_multisig (const epee::wipeable_string &password, const std::vector< std::string > &info)
	Finalizes creation of a multisig wallet.
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.
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).
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).
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
std::string	path () const
bool	verify_password (const epee::wipeable_string &password)
	verifies given password is correct for default wallet keys file
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.
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.
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.
void	set_seed_language (const std::string &language)
	Sets the seed language.
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.
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_payments_out_sc_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.
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.
std::vector< address_book_row >	get_address_book () const
	GUI Address book get/store.
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.
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.
void	set_account_tag (const std::set< uint32_t > &account_indices, const std::string &tag)
	Set a tag to the given accounts.
void	set_account_tag_description (const std::string &tag, const std::string &description)
	Set the label of the given tag.
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
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
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)
template<typename T>
T	decrypt (const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated) const

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.
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.
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.
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.
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.
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
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.
static std::string	get_human_readable_timestamp (uint64_t ts)
	Check if wallet file path is valid format.
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 562 of file wallet2.h.

payment_container

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

Definition at line 450 of file wallet2.h.

transfer_container

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

Definition at line 449 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 1102 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)
{
}

Here is the call graph for this function:

~wallet2()

tools::wallet2::~wallet2

(

)

Definition at line 1169 of file wallet2.cpp.

{
}

Member Function Documentation

account_major_offset() [1/2]

uint32_t tools::wallet2::account_major_offset ( ) const

inline

Definition at line 811 of file wallet2.h.

{return m_account_major_offset;}

account_major_offset() [2/2]

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

inline

Definition at line 810 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

add_checkpoint()

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

Definition at line 13766 of file wallet2.cpp.

                                                           {
    m_checkpoints.add_checkpoint(height, hash);
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_subaddress()

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

Definition at line 1470 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 1463 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 7860 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

adjust_priority()

uint32_t tools::wallet2::adjust_priority

(

uint32_t

priority

)

Definition at line 7877 of file wallet2.cpp.

{
  // just return 1 for normal priority for aurelius instead of being concerned with backlog and adjusting priority because fees are 0 for everyone
  return 1;
 
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

always_confirm_transfers() [1/2]

bool tools::wallet2::always_confirm_transfers ( ) const

inline

Definition at line 1065 of file wallet2.h.

{ return m_always_confirm_transfers; }

always_confirm_transfers() [2/2]

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

inline

Definition at line 1066 of file wallet2.h.

{ m_always_confirm_transfers = always; }

ask_password() [1/2]

AskPasswordType tools::wallet2::ask_password ( ) const

inline

Definition at line 1079 of file wallet2.h.

{ return m_ask_password; }

ask_password() [2/2]

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

inline

Definition at line 1080 of file wallet2.h.

{ m_ask_password = ask; }

auto_low_priority() [1/2]

bool tools::wallet2::auto_low_priority ( ) const

inline

Definition at line 1093 of file wallet2.h.

{ return m_auto_low_priority; }

Here is the caller graph for this function:

auto_low_priority() [2/2]

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

inline

Definition at line 1094 of file wallet2.h.

{ m_auto_low_priority = value; }

auto_refresh() [1/2]

bool tools::wallet2::auto_refresh ( ) const

inline

Definition at line 1075 of file wallet2.h.

{ return m_auto_refresh; }

auto_refresh() [2/2]

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

inline

Definition at line 1076 of file wallet2.h.

{ m_auto_refresh = r; }

balance()

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

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

Here is the caller graph for this function:

balance_all()

uint64_t tools::wallet2::balance_all

(

bool

public_blockchain

)

const

Definition at line 6292 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

blackball_output()

bool tools::wallet2::blackball_output

(

const std::pair< uint64_t, uint64_t > &

output

)

Definition at line 8175 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

callback() [1/2]

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

inline

Definition at line 762 of file wallet2.h.

{ return m_callback; }

Here is the caller graph for this function:

callback() [2/2]

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

inline

Definition at line 763 of file wallet2.h.

{ m_callback = callback; }

Here is the call 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 4320 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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_connection()

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

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

Here is the caller 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 11790 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:

Here is the caller 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 11163 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:

Here is the caller 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 11276 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:

Here is the caller 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 11323 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:

Here is the caller 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 11291 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 11527 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:

Here is the caller 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 11576 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 10694 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:

Here is the caller 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 10665 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:

Here is the caller 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 10655 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:

Here is the caller graph for this function:

commit_tx() [1/2]

void tools::wallet2::commit_tx

(

pending_tx &

ptx_vector

)

Definition at line 6887 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 6967 of file wallet2.cpp.

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

Here is the call graph for this function:

confirm_backlog() [1/2]

bool tools::wallet2::confirm_backlog ( ) const

inline

Definition at line 1087 of file wallet2.h.

{ return m_confirm_backlog; }

confirm_backlog() [2/2]

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

inline

Definition at line 1088 of file wallet2.h.

{ m_confirm_backlog = always; }

confirm_export_overwrite() [1/2]

bool tools::wallet2::confirm_export_overwrite ( ) const

inline

Definition at line 1091 of file wallet2.h.

{ return m_confirm_export_overwrite; }

confirm_export_overwrite() [2/2]

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

inline

Definition at line 1092 of file wallet2.h.

{ m_confirm_export_overwrite = always; }

confirm_missing_payment_id() [1/2]

bool tools::wallet2::confirm_missing_payment_id ( ) const

inline

Definition at line 1077 of file wallet2.h.

{ 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 1078 of file wallet2.h.

{ 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 1103 of file wallet2.h.

{ 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 1104 of file wallet2.h.

{ 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 9725 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 10359 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; //public migration **NOT** SC migration. SC migration tx are just vanilla v3 tx.
  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:

Here is the caller 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 10439 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:

Here is the caller 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 10416 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:

Here is the caller graph for this function:

create_unmixable_sweep_transactions()

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

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt() [1/2]

template<typename T>

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

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

Here is the call graph for this function:

decrypt() [2/2]

template<typename T = std::string>

T tools::wallet2::decrypt	(	const std::string &	ciphertext,
		const crypto::secret_key &	skey,
		bool	authenticated = true ) const

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt_keys() [1/2]

void tools::wallet2::decrypt_keys

(

const crypto::chacha_key &

key

)

Definition at line 4752 of file wallet2.cpp.

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

Here is the call graph for this function:

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 4765 of file wallet2.cpp.

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

Here is the call graph for this function:

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 13250 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

default_mixin() [1/2]

uint32_t tools::wallet2::default_mixin ( ) const

inline

Definition at line 1071 of file wallet2.h.

{ return m_default_mixin; }

default_mixin() [2/2]

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

inline

Definition at line 1072 of file wallet2.h.

{ m_default_mixin = m; }

deinit()

bool tools::wallet2::deinit

(

)

Definition at line 4031 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

delete_address_book_row()

bool tools::wallet2::delete_address_book_row

(

std::size_t

row_id

)

Definition at line 3466 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

device_derivation_path() [1/2]

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

inline

Definition at line 1111 of file wallet2.h.

{ return m_device_derivation_path; }

Here is the caller graph for this function:

device_derivation_path() [2/2]

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

inline

Definition at line 1112 of file wallet2.h.

{ m_device_derivation_path = device_derivation_path; }

Here is the call 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 1188 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 1109 of file wallet2.h.

{ return m_device_name; }

Here is the caller graph for this function:

device_name() [2/2]

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

inline

Definition at line 1110 of file wallet2.h.

{ m_device_name = device_name; }

Here is the call 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 1183 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 10901 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

dump_tx_to_str()

std::string tools::wallet2::dump_tx_to_str

(

const std::vector< pending_tx > &

ptx_vector

)

const

Definition at line 6984 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

enable_dns()

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

inline

Definition at line 1383 of file wallet2.h.

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

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

Here is the call graph for this function:

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 13212 of file wallet2.cpp.

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

Here is the call graph for this function:

encrypt() [4/4]

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

Definition at line 13207 of file wallet2.cpp.

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

Here is the call graph for this function:

encrypt_keys() [1/2]

void tools::wallet2::encrypt_keys

(

const crypto::chacha_key &

key

)

Definition at line 4746 of file wallet2.cpp.

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

Here is the call graph for this function:

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 4758 of file wallet2.cpp.

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

Here is the call graph for this function:

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 13217 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller 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 13543 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);
}

Here is the call graph for this function:

estimate_blockchain_height()

uint64_t tools::wallet2::estimate_blockchain_height

(

)

Definition at line 4990 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

expand_subaddresses()

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

Definition at line 1478 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 746 of file wallet2.h.

{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 745 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 12221 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 12191 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:

Here is the caller 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 12994 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:

Here is the caller 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 12723 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

export_outputs_to_str()

std::string tools::wallet2::export_outputs_to_str

(

bool

all = false

)

const

Definition at line 12744 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

export_payments()

wallet2::payment_container tools::wallet2::export_payments

(

)

const

Definition at line 12665 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

find_and_save_rings()

bool tools::wallet2::find_and_save_rings

(

bool

force = true

)

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

freeze() [1/2]

void tools::wallet2::freeze

(

const crypto::key_image &

ki

)

Definition at line 1605 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 1584 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 1615 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 1631 of file wallet2.cpp.

{
  return td.m_frozen;
}

frozen() [3/3]

bool tools::wallet2::frozen

(

size_t

idx

)

const

Definition at line 1598 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

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

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

Here is the call graph for this function:

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 4869 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 734 of file wallet2.h.

{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 735 of file wallet2.h.

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

Here is the caller graph for this function:

get_address()

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

inline

Definition at line 793 of file wallet2.h.

{ 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 798 of file wallet2.h.

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

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 1150 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_attribute()

std::string tools::wallet2::get_attribute

(

const std::string &

key

)

const

Definition at line 12018 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_base_fee()

uint64_t tools::wallet2::get_base_fee

(

)

const

Definition at line 7785 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){
      if (use_fork_rules(HF_VERSION_ZERO_FEE)){
          return FEE_PER_KB_V11;
      } else{
          return FEE_PER_KB_V6;
      }
  }
 
 
  return get_dynamic_base_fee_estimate(); //this never gets hit for any version before 100
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_blockchain_current_height()

uint64_t tools::wallet2::get_blockchain_current_height ( ) const

inline

Definition at line 898 of file wallet2.h.

{ 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 13393 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:

Here is the caller graph for this function:

get_bytes_received()

uint64_t tools::wallet2::get_bytes_received

(

)

const

Definition at line 13761 of file wallet2.cpp.

{
  return m_http_client.get_bytes_received();
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_bytes_sent()

uint64_t tools::wallet2::get_bytes_sent

(

)

const

Definition at line 13756 of file wallet2.cpp.

{
  return m_http_client.get_bytes_sent();
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_confirm_backlog_threshold()

uint32_t tools::wallet2::get_confirm_backlog_threshold ( ) const

inline

Definition at line 1090 of file wallet2.h.

{ return m_confirm_backlog_threshold; };

get_daemon_address()

std::string tools::wallet2::get_daemon_address

(

)

const

Definition at line 11926 of file wallet2.cpp.

{
  return m_daemon_address;
}

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_daemon_blockchain_target_height()

uint64_t tools::wallet2::get_daemon_blockchain_target_height

(

std::string &

err

)

Definition at line 11949 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_daemon_login()

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

inline

Definition at line 1165 of file wallet2.h.

{ 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 1073 of file wallet2.h.

{ return m_default_priority; }

get_description()

std::string tools::wallet2::get_description

(

)

const

Definition at line 12031 of file wallet2.cpp.

{
  return get_attribute(ATTRIBUTE_DESCRIPTION);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_device_last_key_image_sync()

uint64_t tools::wallet2::get_device_last_key_image_sync ( ) const

inline

Definition at line 907 of file wallet2.h.

{ return m_device_last_key_image_sync; }

get_device_type()

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

inline

Definition at line 831 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_fee_multiplier()

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

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

Here is the caller graph for this function:

get_fee_quantization_mask()

uint64_t tools::wallet2::get_fee_quantization_mask

(

)

const

Definition at line 7807 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_hard_fork_info()

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

Definition at line 10714 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");
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_human_readable_timestamp()

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 1039 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 1458 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 11921 of file wallet2.cpp.

{
  return m_keys_file;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_last_block_reward()

uint64_t tools::wallet2::get_last_block_reward ( ) const

inline

Definition at line 906 of file wallet2.h.

{ return m_last_block_reward; }

get_light_wallet_blockchain_height()

uint64_t tools::wallet2::get_light_wallet_blockchain_height ( ) const

inline

Definition at line 780 of file wallet2.h.

{ 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 779 of file wallet2.h.

{ return m_light_wallet_scanned_block_height; }

get_max_ring_size()

uint64_t tools::wallet2::get_max_ring_size

(

)

const

Definition at line 7851 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_message_store() [1/2]

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

inline

Definition at line 1367 of file wallet2.h.

{ return m_message_store; };

get_message_store() [2/2]

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

inline

Definition at line 1368 of file wallet2.h.

{ return m_message_store; };

get_min_output_count()

uint32_t tools::wallet2::get_min_output_count ( ) const

inline

Definition at line 1082 of file wallet2.h.

{ return m_min_output_count; }

get_min_output_value()

uint64_t tools::wallet2::get_min_output_value ( ) const

inline

Definition at line 1084 of file wallet2.h.

{ return m_min_output_value; }

get_min_ring_size()

uint64_t tools::wallet2::get_min_ring_size

(

)

const

Definition at line 7836 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_multisig_info()

std::string tools::wallet2::get_multisig_info

(

)

const

Get a packaged multisig information string

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

Here is the caller 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 1327 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 12898 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 12891 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:

Here is the caller 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 12906 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 12914 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]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_multisig_wallet_state()

mms::multisig_wallet_state tools::wallet2::get_multisig_wallet_state

(

)

const

Definition at line 13615 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_num_rct_outputs()

uint64_t tools::wallet2::get_num_rct_outputs

(

)

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

Here is the caller graph for this function:

get_num_subaddress_accounts()

size_t tools::wallet2::get_num_subaddress_accounts ( ) const

inline

Definition at line 801 of file wallet2.h.

{ 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 802 of file wallet2.h.

{ 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 1155 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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 6346 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) //avoid as processed by separate function
      continue;
    if(i->second.m_is_sc_migration) //avoid as processed by separate function
      continue;
    confirmed_payments.push_back(*i);
  }
}//----------------------------------------------------------------------------------------------------

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_payments_out_sc_migration()

void tools::wallet2::get_payments_out_sc_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 6380 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_sc_migration)
      continue;
  confirmed_payments.push_back(*i);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_refresh_from_block_height()

uint64_t tools::wallet2::get_refresh_from_block_height ( ) const

inline

Definition at line 743 of file wallet2.h.

{return m_refresh_from_block_height;}

get_refresh_type()

RefreshType tools::wallet2::get_refresh_type ( ) const

inline

Definition at line 822 of file wallet2.h.

{ 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 11669 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:

Here is the caller 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 8057 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_ring_database()

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

inline

Definition at line 1341 of file wallet2.h.

{ 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 8034 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:

Here is the caller 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 1301 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 1417 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 11047 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:

Here is the caller graph for this function:

get_subaddress()

cryptonote::account_public_address tools::wallet2::get_subaddress

(

const cryptonote::subaddress_index &

index

)

const

Definition at line 1430 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 1452 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 1437 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 1518 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 808 of file wallet2.h.

{ 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 1445 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

Here is the call graph for this function:

get_transfer_details()

const wallet2::transfer_details & tools::wallet2::get_transfer_details

(

size_t

idx

)

const

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

Here is the caller graph for this function:

get_transfers()

void tools::wallet2::get_transfers

(

wallet2::transfer_container &

incoming_transfers

)

const

Definition at line 6315 of file wallet2.cpp.

{
  incoming_transfers = m_transfers;
}

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_tx_note()

std::string tools::wallet2::get_tx_note

(

const crypto::hash &

txid

)

const

Definition at line 11992 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller 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 11417 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 12143 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_wallet_file()

std::string tools::wallet2::get_wallet_file

(

)

const

Definition at line 11916 of file wallet2.cpp.

{
  return m_wallet_file;
}

Here is the call graph for this function:

Here is the caller graph for this function:

has_multisig_partial_key_images()

bool tools::wallet2::has_multisig_partial_key_images

(

)

const

Definition at line 5647 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

has_stagenet_option()

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

static

Definition at line 1178 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 1173 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 5657 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hash_m_transfer()

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

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

Here is the caller 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 13710 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:

Here is the caller graph for this function:

ignore_fractional_outputs() [1/2]

bool tools::wallet2::ignore_fractional_outputs ( ) const

inline

Definition at line 1101 of file wallet2.h.

{ return m_ignore_fractional_outputs; }

ignore_fractional_outputs() [2/2]

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

inline

Definition at line 1102 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 12278 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 12333 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] != SPENT_STATUS::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] == SPENT_STATUS::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;
      if(td.m_tx.version == 3){
        cryptonote::account_public_address dest_address = boost::get<cryptonote::txout_to_key_public>(td.m_tx.vout[0].target).address; 
          bool is_portal_address;
          if(m_nettype == MAINNET){
              is_portal_address = epee::string_tools::pod_to_hex(dest_address.m_spend_public_key) == "8ce0f34fd37c7f7d07c44024eb5b3cdf275d1b3e75c3464b808dce532e861137" && epee::string_tools::pod_to_hex(dest_address.m_view_public_key) == "2b95a2eb2c62253c57e82b082b850bbf22a1a7829aaea09c7c1511c1cced4375";
          }else{
              is_portal_address = epee::string_tools::pod_to_hex(dest_address.m_spend_public_key) == "5bd0c0e25eee6133850edd2b255ed9e3d6bb99fd5f08b7b5cf7f2618ad6ff2a3" && epee::string_tools::pod_to_hex(dest_address.m_view_public_key) == "5866666666666666666666666666666666666666666666666666666666666666";
          }
        pd.m_is_sc_migration = is_portal_address;
      }
      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:

Here is the caller 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 12650 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);
}

Here is the call graph for this function:

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 )

Definition at line 12623 of file wallet2.cpp.

{
  if (key_images.size() + offset > m_transfers.size())
  {
    LOG_PRINT_L1("More key images returned that we know outputs for");
    return false;
  }
  for (size_t ki_idx = 0; ki_idx < key_images.size(); ++ki_idx)
  {
    const size_t transfer_idx = ki_idx + offset;
    if (selected_transfers && selected_transfers.get().find(transfer_idx) == selected_transfers.get().end())
      continue;
 
    transfer_details &td = m_transfers[transfer_idx];
    if (td.m_key_image_known && !td.m_key_image_partial && td.m_key_image != key_images[ki_idx])
      LOG_PRINT_L0("WARNING: imported key image differs from previously known key image at index " << ki_idx << ": trusting imported one");
    td.m_key_image = key_images[ki_idx];
    m_key_images[td.m_key_image] = transfer_idx;
    td.m_key_image_known = true;
    td.m_key_image_request = false;
    td.m_key_image_partial = false;
    m_pub_keys[td.get_public_key()] = transfer_idx;
  }
 
  return true;
}

Here is the call graph for this function:

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

Here is the caller 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 12763 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 12828 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

import_payments()

void tools::wallet2::import_payments

(

const payment_container &

payments

)

Definition at line 12674 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 12682 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 1282 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 1193 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 1326 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:

Here is the caller 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 1319 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:

Here is the caller 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 1333 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:

Here is the caller graph for this function:

is_deprecated()

bool tools::wallet2::is_deprecated

(

)

const

Tells if the wallet file is deprecated.

Definition at line 1546 of file wallet2.cpp.

{
  return is_old_file_format;
}

is_deterministic()

bool tools::wallet2::is_deterministic

(

)

const

Checks if deterministic wallet.

Definition at line 1293 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 8236 of file wallet2.cpp.

{
  return m_keys_file_locker->locked();
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_output_blackballed()

bool tools::wallet2::is_output_blackballed

(

const std::pair< uint64_t, uint64_t > &

output

)

const

Definition at line 8206 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_synced()

bool tools::wallet2::is_synced

(

)

const

Definition at line 13480 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_transfer_unlocked() [1/2]

bool tools::wallet2::is_transfer_unlocked

(

const transfer_details &

td

)

const

Definition at line 6565 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_transfer_unlocked() [2/2]

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

Definition at line 6570 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;
}

Here is the call graph for this function:

is_trusted_daemon()

bool tools::wallet2::is_trusted_daemon ( ) const

inline

Definition at line 765 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_unattended()

bool tools::wallet2::is_unattended ( ) const

inline

Definition at line 1274 of file wallet2.h.

{ return m_unattended; }

key_on_device()

bool tools::wallet2::key_on_device ( ) const

inline

Definition at line 830 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

key_reuse_mitigation2() [1/2]

bool tools::wallet2::key_reuse_mitigation2 ( ) const

inline

Definition at line 1097 of file wallet2.h.

{ return m_key_reuse_mitigation2; }

key_reuse_mitigation2() [2/2]

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

inline

Definition at line 1098 of file wallet2.h.

{ 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 777 of file wallet2.h.

{ 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 9438 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:

Here is the caller graph for this function:

light_wallet_get_address_txs()

void tools::wallet2::light_wallet_get_address_txs

(

)

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

Here is the caller 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 8268 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:

Here is the caller graph for this function:

light_wallet_get_unspent_outs()

void tools::wallet2::light_wallet_get_unspent_outs

(

)

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

Here is the caller 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 9269 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:

Here is the caller 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 9667 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:

Here is the caller graph for this function:

light_wallet_login()

bool tools::wallet2::light_wallet_login

(

bool &

new_address

)

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

Here is the caller 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 9642 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:

Here is the caller graph for this function:

load()

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

Definition at line 5833 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_options::overwrite_existing);
            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_options::overwrite_existing);
        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 7549 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:

Here is the caller 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 7583 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:

Here is the caller 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 7321 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:

Here is the caller 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 7014 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:

Here is the caller graph for this function:

lock_keys_file()

bool tools::wallet2::lock_keys_file

(

)

Definition at line 8214 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 1261 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 1233 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 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 1227 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 5145 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 5466 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the caller graph for this function:

merge_destinations() [1/2]

bool tools::wallet2::merge_destinations ( ) const

inline

Definition at line 1086 of file wallet2.h.

{ return m_merge_destinations; }

merge_destinations() [2/2]

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

inline

Definition at line 1085 of file wallet2.h.

{ m_merge_destinations = merge; }

Here is the caller graph for this function:

multisig()

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

Definition at line 5634 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 824 of file wallet2.h.

{ 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 5712 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 7505 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_payment_id()

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

static

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

Here is the caller 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 5725 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 7342 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:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

path()

std::string tools::wallet2::path

(

)

const

Definition at line 6027 of file wallet2.cpp.

{
  return m_wallet_file;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 6740 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

print_ring_members() [1/2]

bool tools::wallet2::print_ring_members ( ) const

inline

Definition at line 1067 of file wallet2.h.

{ return m_print_ring_members; }

print_ring_members() [2/2]

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

inline

Definition at line 1068 of file wallet2.h.

{ m_print_ring_members = value; }

public_transactions_required()

bool tools::wallet2::public_transactions_required ( ) const

inline

Definition at line 900 of file wallet2.h.

{ return nettype() == cryptonote::network_type::MAINNET ? get_blockchain_current_height() >= (1175315 - CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS) : get_blockchain_current_height() >= (1086402 - 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:

Here is the caller 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 4807 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 1390 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 3060 of file wallet2.cpp.

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

Here is the call graph for this function:

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 3851 of file wallet2.cpp.

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

Here is the call graph for this function:

refresh() [3/4]

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

Definition at line 3066 of file wallet2.cpp.

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

Here is the call graph for this function:

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 3493 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)));
 
        //get the testnet bridge address - should be same as mainnet because of our netbyte being erroneously set to the same thing when Electroneum was first created
        // cryptonote::account_public_address bridge_public_address;
        // std::string portal_address_viewkey_hex_str = "5866666666666666666666666666666666666666666666666666666666666666"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000
        // std::string portal_address_spendkey_hex_str = "5bd0c0e25eee6133850edd2b255ed9e3d6bb99fd5f08b7b5cf7f2618ad6ff2a3"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000
        // epee::string_tools::hex_to_pod(portal_address_viewkey_hex_str, bridge_public_address.m_view_public_key);
        // epee::string_tools::hex_to_pod(portal_address_spendkey_hex_str, bridge_public_address.m_spend_public_key);
        // std::string bridge_address = cryptonote::get_account_address_as_str(this->nettype(), false, bridge_public_address); //OK
 
        //generate the coinbase burn address. spendkey is "9511fabcb699b4f9dffc1779713d0dd7eb1ca56ba5b8ab8d3253a0a6ccf736b3", address "etnkCys4uGhSi9h48ajL9vBDJTcn2s2ttXtXq3SXWPAbiMHNhHitu5fJ8QgRfFWTzmJ8QgRfFWTzmJ8QgRfFWTzm4t51HTfCtK"
        //cryptonote::account_public_address coinbase_burn_address;
        //crypto::hash h;
        //crypto::ec_point point;
        //epee::string_tools::hex_to_pod("714c8d8eeee5243e7f266e5210f76f58b8b1d6330cedfbc4eda6d5947b212012", h); // genesis hash hex ---> hash type
        //crypto::hash_to_point(h, point); // generate curve point (burn address spendkey) deterministically in such a way that we can't recover the private key
        //crypto::public_key coinbase_burn_address_spendkey;
        //std::copy(std::begin(point.data), std::end(point.data), std::begin(coinbase_burn_address_spendkey.data)); // serialise point to pubkey type
        //std::string coinbase_burn_address_spendkey_hex_str = epee::string_tools::pod_to_hex(coinbase_burn_address_spendkey); // for testing only. pub spend =
        //std::string coinbase_burn_address_viewkey_hex_str = "5866666666666666666666666666666666666666666666666666666666666666"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000
        //coinbase_burn_address.m_spend_public_key = coinbase_burn_address_spendkey;
        //epee::string_tools::hex_to_pod(coinbase_burn_address_viewkey_hex_str, coinbase_burn_address.m_view_public_key);
        //std::string coinbase_burn_address_str = cryptonote::get_account_address_as_str(this->nettype(), false, coinbase_burn_address); //OK
 
 
        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 ? 1086402 + 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); // BRIDGE PORTAL ADDRESS
                            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 to the public version of the blockchain has completed. Please use the command show_transfers (CLI Wallet) or get_transfers (RPC Wallet) to see the details of your migration transactions.");
            }
 
        }  catch(...) {
            THROW_WALLET_EXCEPTION(error::wallet_internal_error, "V9 (Privatised)-->V10 (Public) wallet migration failed.");
        }
 
        try {
            // V10 Migration to Electroneum Smart Chain
            cryptonote::account_public_address portal_address;
            std::string portal_address_viewkey_hex_str;
            std::string portal_address_spendkey_hex_str;
            if(m_nettype == MAINNET){
                portal_address_viewkey_hex_str = "2b95a2eb2c62253c57e82b082b850bbf22a1a7829aaea09c7c1511c1cced4375";
                portal_address_spendkey_hex_str = "8ce0f34fd37c7f7d07c44024eb5b3cdf275d1b3e75c3464b808dce532e861137";
            }else{
                portal_address_viewkey_hex_str = "5866666666666666666666666666666666666666666666666666666666666666"; //private view is just 0100000000000000000000000000000000000000000000000000000000000000
                portal_address_spendkey_hex_str = "5bd0c0e25eee6133850edd2b255ed9e3d6bb99fd5f08b7b5cf7f2618ad6ff2a3"; //
            }
 
            bool portal_wallet =  //if the portal address wallet ever needs opening, don't allow it to sweep to itself
                    epee::string_tools::pod_to_hex(get_address().m_spend_public_key) ==
                    portal_address_spendkey_hex_str &&
                    epee::string_tools::pod_to_hex(get_address().m_view_public_key) == portal_address_viewkey_hex_str;
 
            epee::string_tools::hex_to_pod(portal_address_spendkey_hex_str, portal_address.m_spend_public_key);
            epee::string_tools::hex_to_pod(portal_address_viewkey_hex_str, portal_address.m_view_public_key);
 
            // ONLY do migration transactions after the fork block
            uint64_t smartchain_migration_minheight = this->nettype() == MAINNET ? 1811310 : 1455270;
            if (this->get_blockchain_current_height() > smartchain_migration_minheight) {
                // check that unlocked balance = unlocked balance as a best-effort to ensure that we're not migrating the funds whilst more are in transit/confirming
                if ((!portal_wallet) && (this->balance_all(true) != 0) &&
                    (this->unlocked_balance_all(true) == this->balance_all(true))) {
                    std::cout << std::endl << "You are beginning your token migration over to the Electroneum Smart Chain." << std::endl;
                    std::cout << "This transaction is feeless. For further information, please read our documentation over at https:///developer.electroneum.com/migration-to-smart-chain/overview" << std::endl;
                    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, true);
                    }
                    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*/) {
                                std::set<uint32_t> subaddress_source{index.minor};
                                std::vector<wallet2::pending_tx> ptx_vector = this->create_transactions_all(0,
                                                                                                            portal_address /*dest address (portal address for bridge)*/,
                                                                                                           0 /*is dest a subaddress*/,
                                                                                                            1 /*one output only*/, //???????
                                                                                                            0 /* don't mix*/,
                                                                                                            0 /*default unlock time*/,
                                                                                                            1 /*priority - set low in case they don't have fees for high priority but do for low priority*/,
                                                                                                            vector<uint8_t>() /*empty tx extra */,
                                                                                                            index.major /*account index*/,
                                                                                                            subaddress_source /*source subaddr index*/,
                                                                                                            false /*migrate to transparent chain*/);
                                this->commit_tx(ptx_vector);
                            }
                        }
                      }
                      std::cout << std::endl;
                      std::cout << "Migration to Smart Chain portal address completed. Please use the command show_transfers (CLI Wallet) or get_transfers (RPC Wallet) to see the details of your Smart Chain migration transactions." << std::endl;
                      std::cout << "Please note that the entire migration process is not instant and your funds may take some time to show up in the Smart Chain." << std::endl;
                      std::cout << "You can find your SmartChain address using the \"spendkey\" command in the CLI wallet." << std::endl;
                }
            }
        } catch(...) {
        THROW_WALLET_EXCEPTION(error::wallet_internal_error, "V10 Smart Chain migration failed.");
    }
}

Here is the call graph for this function:

remove_obsolete_pool_txs()

void tools::wallet2::remove_obsolete_pool_txs

(

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

tx_hashes

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

rescan_blockchain()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

rescan_spent()

void tools::wallet2::rescan_spent

(

)

Definition at line 6417 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
 
  // M_TRANSFERS is a container of  OUTPUTS and NOT a container of entire transfers!
 
  // The logic for dealing with publicised (v8 hf) outputs is as follows:
  // 1. Check the output block height in m_transfers. If it's >= v8 hard fork height, the output must be a public one,
  // 2. m_transfers contains the tx hash and relative out index for each output which uniquely determine
  //    'chainstate UTXOs' in the blockchain database; if a chainstate UTXO is present in the DB, the output is truly
  //    unspent. However nonexistence of the UTXO in the db doesn't mean it's spent, only that it doesn't exist. So we
  //    must first check (by some means) that the output did exist. Use the tx input db.
  // 3. Call the daemon for this output and ask of the spent status.
  // 4. Set the correct spent status of the output in m_transfers
 
  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); // 1000 or less if we dont have 1000
    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) //loop over key images for the outputs in m_transfers and put the key image in the request
      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); //fire off the check command
    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));
  }
 
 
  // urgent code update so just duplicate code above for public outputs
    uint64_t v8height = m_nettype == TESTNET ? 446674 : 589169;
    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("Preparing is_public_output_spent request for outputs " << start_offset << " - " << (start_offset + n_outputs - 1) << ", out of " << m_transfers.size());
 
        COMMAND_RPC_IS_PUBLIC_OUTPUT_SPENT::request req = AUTO_VAL_INIT(req);
        COMMAND_RPC_IS_PUBLIC_OUTPUT_SPENT::response daemon_resp = AUTO_VAL_INIT(daemon_resp);
 
        // Prepare the request for public outputs only for m_transfers after v8 height
        for (size_t k = start_offset; k < start_offset + n_outputs; ++k) {
            if (m_transfers[k].m_block_height >= v8height) {
                public_output pub_out;
                pub_out.txid = epee::string_tools::pod_to_hex(m_transfers[k].m_txid);
                pub_out.relative_out_index = static_cast<uint64_t>(m_transfers[k].m_internal_output_index);
                req.public_outputs.push_back(pub_out);
            }
        }
 
        if(req.public_outputs.size() == 0){
            MDEBUG("No public outs found in the range: " << start_offset << " - " << (start_offset + n_outputs - 1) << ", out of " << m_transfers.size() << ", skipping chunk");
            continue;
        }
        // We always call the daemon, but the request may be empty if no outputs meet the criteria
        m_daemon_rpc_mutex.lock();
        bool r = invoke_http_json("/is_public_output_spent", req, daemon_resp, rpc_timeout);
        m_daemon_rpc_mutex.unlock();
        THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "is_public_output_spent");
        THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "is_public_output_spent");
        THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::is_public_output_spent_error, get_rpc_status(daemon_resp.status));
        THROW_WALLET_EXCEPTION_IF(daemon_resp.spent_status.size() != req.public_outputs.size(), error::wallet_internal_error,
                                  "daemon returned wrong response for is_public_output_spent, wrong amount count = " +
                                  std::to_string(daemon_resp.spent_status.size()) + ", expected " +  std::to_string(req.public_outputs.size()));
 
        // Update spent_status only for outputs that were included in the request. do this by iterating through m_transfers and if it's >= v8 height
        // then set the corresponding spent status for the same index. use a request index like so because not always does n == request index
        // because not all outputs are public outputs
        size_t request_index = 0;
        for (size_t k = start_offset; k < start_offset + n_outputs; ++k) {
            if (m_transfers[k].m_block_height >= v8height) {
                spent_status[k] = daemon_resp.spent_status[request_index++];
            }
        }
    }
 
  // update spent status in m_transfers
  // spent_status[i] guide:
  //    UNSPENT = 0,
  //    SPENT_IN_BLOCKCHAIN = 1,
  //    SPENT_IN_POOL = 2,
  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. only skip in this case IF it isn't a public output
    if (!(m_transfers[i].m_block_height >= v8height) && (!td.m_key_image_known || td.m_key_image_partial)) //we will hit this for all public outs, so modify here
      continue;
 
    if (td.m_spent != (spent_status[i] != SPENT_STATUS::UNSPENT))  // if output in m_transfers is unspent and the daemon says spent or the other way round, handle either which way
    {
      if (td.m_spent) //  given parent if statement, spent means we need to change to unspent
      {
          if(!(m_transfers[i].m_block_height >= v8height)){
              LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as unspent, it was marked as spent");
          } else{
              LOG_PRINT_L0("Marking public output " << i << " (txid: " << td.m_txid << ", index: " << td.m_internal_output_index << ") as unspent, it was marked as spent");
          }
        set_unspent(i);
        td.m_spent_height = 0;
      }
      else //  given parent if statement, unspent means we need to change to spent
      {
          if (!(m_transfers[i].m_block_height >= v8height)) {
              LOG_PRINT_L0("Marking output " << i << " (key image: " << epee::string_tools::pod_to_hex(td.m_key_image) << ") as spent, it was marked as unspent");
          } else {
              LOG_PRINT_L0("Not marking output " << i << " (txid: " << epee::string_tools::pod_to_hex(td.m_txid) << ", index: " << td.m_internal_output_index << ") as spent since block height " << td.m_block_height << " is below the threshold of " << v8height);
          }
          set_spent(i, td.m_spent_height);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller 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 5110 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:

Here is the caller 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 5670 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller 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 7469 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 7492 of file wallet2.cpp.

{
  return save_multisig_tx(make_multisig_tx_set(ptx_vector));
}

Here is the call graph for this function:

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 7497 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 7431 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:

Here is the caller 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 6975 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:

Here is the caller graph for this function:

segregate_pre_fork_outputs() [1/2]

bool tools::wallet2::segregate_pre_fork_outputs ( ) const

inline

Definition at line 1095 of file wallet2.h.

{ 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 1096 of file wallet2.h.

{ m_segregate_pre_fork_outputs = value; }

segregation_height() [1/2]

uint64_t tools::wallet2::segregation_height ( ) const

inline

Definition at line 1099 of file wallet2.h.

{ return m_segregation_height; }

segregation_height() [2/2]

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

inline

Definition at line 1100 of file wallet2.h.

{ m_segregation_height = height; }

select_available_mixable_outputs()

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

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

select_available_unmixable_outputs()

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

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

serialize()

template<class t_archive>

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

inline

Definition at line 910 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 12056 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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_attribute()

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

Definition at line 12013 of file wallet2.cpp.

{
  m_attributes[key] = value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_confirm_backlog_threshold()

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

inline

Definition at line 1089 of file wallet2.h.

{ 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 1268 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 1074 of file wallet2.h.

{ m_default_priority = p; }

set_description()

void tools::wallet2::set_description

(

const std::string &

description

)

Definition at line 12026 of file wallet2.cpp.

{
  set_attribute(ATTRIBUTE_DESCRIPTION, description);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_light_wallet()

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

inline

Definition at line 778 of file wallet2.h.

{ m_light_wallet = light_wallet; }

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 1081 of file wallet2.h.

{ m_min_output_count = count; }

set_min_output_value()

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

inline

Definition at line 1083 of file wallet2.h.

{ m_min_output_value = value; }

set_offline()

void tools::wallet2::set_offline

(

bool

offline = true

)

Definition at line 5810 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();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_refresh_from_block_height()

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

inline

Definition at line 742 of file wallet2.h.

{m_refresh_from_block_height = height;}

set_refresh_type()

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

inline

Definition at line 821 of file wallet2.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_ring_database()

bool tools::wallet2::set_ring_database

(

const std::string &

filename

)

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

Here is the caller 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 1425 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 1528 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;
}

set_subaddress_lookahead()

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

Definition at line 1535 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;
}

set_trusted_daemon()

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

inline

Definition at line 766 of file wallet2.h.

{ 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 12000 of file wallet2.cpp.

{
  m_tx_device[txid] = aux;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

set_tx_note()

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

Definition at line 11987 of file wallet2.cpp.

{
  m_tx_notes[txid] = note;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_tx_notify()

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

inline

Definition at line 1377 of file wallet2.h.

{ m_tx_notify = notify; }

setup_background_mining() [1/2]

BackgroundMiningSetupType tools::wallet2::setup_background_mining ( ) const

inline

Definition at line 1107 of file wallet2.h.

{ return m_setup_background_mining; }

setup_background_mining() [2/2]

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

inline

Definition at line 1108 of file wallet2.h.

{ m_setup_background_mining = value; }

sign()

std::string tools::wallet2::sign

(

const std::string &

data

)

const

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

Here is the caller 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 12109 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:

Here is the caller 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 7607 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:

Here is the caller 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 7718 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 7710 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 )

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 )

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

Here is the call graph for this function:

Here is the caller graph for this function:

stop()

void tools::wallet2::stop ( )

inline

Definition at line 760 of file wallet2.h.

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

store()

void tools::wallet2::store

(

)

Definition at line 6032 of file wallet2.cpp.

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

Here is the call graph for this function:

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

Here is the caller graph for this function:

store_tx_info() [1/2]

bool tools::wallet2::store_tx_info ( ) const

inline

Definition at line 1069 of file wallet2.h.

{ return m_store_tx_info; }

Here is the caller graph for this function:

store_tx_info() [2/2]

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

inline

Definition at line 1070 of file wallet2.h.

{ 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 899 of file wallet2.h.

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

Here is the call graph for this function:

thaw() [1/2]

void tools::wallet2::thaw

(

const crypto::key_image &

ki

)

Definition at line 1610 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 1591 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 994 of file wallet2.cpp.

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

Here is the call graph for this function:

track_uses() [1/2]

bool tools::wallet2::track_uses ( ) const

inline

Definition at line 1105 of file wallet2.h.

{ return m_track_uses; }

track_uses() [2/2]

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

inline

Definition at line 1106 of file wallet2.h.

{ 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 8952 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:

Here is the caller graph for this function:

unblackball_output()

bool tools::wallet2::unblackball_output

(

const std::pair< uint64_t, uint64_t > &

output

)

Definition at line 8198 of file wallet2.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

unlock_keys_file()

bool tools::wallet2::unlock_keys_file

(

)

Definition at line 8225 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

unset_ring() [1/2]

bool tools::wallet2::unset_ring

(

const crypto::hash &

txid

)

Definition at line 8081 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 8072 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; }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_pool_state()

void tools::wallet2::update_pool_state

(

bool

refreshed = false

)

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

verify()

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

Definition at line 12086 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 5586 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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 5707 of file wallet2.cpp.

{
  return !file_path.empty();
}

Here is the call graph for this function:

Here is the caller graph for this function:

watch_only()

bool tools::wallet2::watch_only ( ) const

inline

Definition at line 825 of file wallet2.h.

{ return m_watch_only; }

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

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol 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 1309 of file wallet2.h.

rpc_timeout

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-5.1.3.1-build/electroneum-5.1.3.1/src/wallet/wallet2.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/wallet/wallet2.cpp