Electroneum::WalletImpl Class Reference

#include <wallet.h>

Inheritance diagram for Electroneum::WalletImpl:

Collaboration diagram for Electroneum::WalletImpl:

Public Member Functions
	WalletImpl (NetworkType nettype=MAINNET, uint64_t kdf_rounds=1)
	~WalletImpl ()
bool	create (const std::string &path, const std::string &password, const std::string &language)
bool	createWatchOnly (const std::string &path, const std::string &password, const std::string &language) const override
	createWatchOnly - Creates a watch only wallet
bool	open (const std::string &path, const std::string &password)
bool	recover (const std::string &path, const std::string &password, const std::string &seed)
bool	recoverFromKeysWithPassword (const std::string &path, const std::string &password, const std::string &language, const std::string &address_string, const std::string &viewkey_string, const std::string &spendkey_string="")
bool	recover (const std::string &path, const std::string &seed)
bool	recoverFromKeys (const std::string &path, const std::string &language, const std::string &address_string, const std::string &viewkey_string, const std::string &spendkey_string="")
bool	recoverFromDevice (const std::string &path, const std::string &password, const std::string &device_name)
Device	getDeviceType () const override
	Queries backing device for wallet keys.
bool	close (bool store=true)
std::string	seed () const override
std::string	getSeedLanguage () const override
void	setSeedLanguage (const std::string &arg) override
int	status () const override
	returns wallet status (Status_Ok | Status_Error)
std::string	errorString () const override
	in case error status, returns error string
void	statusWithErrorString (int &status, std::string &errorString) const override
	returns both error and error string atomically. suggested to use in instead of status() and errorString()
bool	setPassword (const std::string &password) override
bool	setDevicePin (const std::string &password) override
bool	setDevicePassphrase (const std::string &password) override
std::string	address (uint32_t accountIndex=0, uint32_t addressIndex=0) const override
std::string	integratedAddress (const std::string &payment_id) const override
	integratedAddress - returns integrated address for current wallet address and given payment_id. if passed "payment_id" param is an empty string or not-valid payment id string (16 characters hexadecimal string) - random payment_id will be generated
std::string	secretViewKey () const override
	secretViewKey - returns secret view key
std::string	publicViewKey () const override
	publicViewKey - returns public view key
std::string	secretSpendKey () const override
	secretSpendKey - returns secret spend key
std::string	publicSpendKey () const override
	publicSpendKey - returns public spend key
std::string	publicMultisigSignerKey () const override
	publicMultisigSignerKey - returns public signer key
std::string	path () const override
bool	store (const std::string &path) override
	store - stores wallet to file.
std::string	filename () const override
	filename - returns wallet filename
std::string	keysFilename () const override
	keysFilename - returns keys filename. usually this formed as "wallet_filename".keys
bool	init (const std::string &daemon_address, uint64_t upper_transaction_size_limit=0, const std::string &daemon_username="", const std::string &daemon_password="", bool use_ssl=false, bool lightWallet=false) override
	init - initializes wallet with daemon connection params. if daemon_address is local address, "trusted daemon" will be set to true forcibly startRefresh() should be called when wallet is initialized.
bool	connectToDaemon () override
	connectToDaemon - connects to the daemon. TODO: check if it can be removed
ConnectionStatus	connected () const override
	connected - checks if the wallet connected to the daemon
void	setTrustedDaemon (bool arg) override
bool	trustedDaemon () const override
uint64_t	balance (uint32_t accountIndex=0, bool public_blockchain=false) const override
uint64_t	unlockedBalance (uint32_t accountIndex=0, bool public_blockchain=false) const override
uint64_t	blockChainHeight () const override
	blockChainHeight - returns current blockchain height
uint64_t	approximateBlockChainHeight () const override
	approximateBlockChainHeight - returns approximate blockchain height calculated from date/time
uint64_t	estimateBlockChainHeight () const override
	estimateBlockChainHeight - returns estimate blockchain height. More accurate than approximateBlockChainHeight, uses daemon height and falls back to calculation from date/time
uint64_t	daemonBlockChainHeight () const override
	daemonBlockChainHeight - returns daemon blockchain height
uint64_t	daemonBlockChainTargetHeight () const override
	daemonBlockChainTargetHeight - returns daemon blockchain target height
bool	synchronized () const override
	synchronized - checks if wallet was ever synchronized
bool	refresh () override
	refresh - refreshes the wallet, updating transactions from daemon
void	refreshAsync () override
	refreshAsync - refreshes wallet asynchronously.
bool	rescanBlockchain () override
	rescanBlockchain - rescans the wallet, updating transactions from daemon
void	rescanBlockchainAsync () override
	rescanBlockchainAsync - rescans wallet asynchronously, starting from genesys
void	setAutoRefreshInterval (int millis) override
	setAutoRefreshInterval - setup interval for automatic refresh.
int	autoRefreshInterval () const override
	autoRefreshInterval - returns automatic refresh interval in millis
void	setRefreshFromBlockHeight (uint64_t refresh_from_block_height) override
	setRefreshFromBlockHeight - start refresh from block height on recover
uint64_t	getRefreshFromBlockHeight () const override
	getRestoreHeight - get wallet creation height
void	setRecoveringFromSeed (bool recoveringFromSeed) override
	setRecoveringFromSeed - set state recover form seed
void	setRecoveringFromDevice (bool recoveringFromDevice) override
	setRecoveringFromDevice - set state to recovering from device
void	setSubaddressLookahead (uint32_t major, uint32_t minor) override
	setSubaddressLookahead - set size of subaddress lookahead
bool	watchOnly () const override
	watchOnly - checks if wallet is watch only
bool	rescanSpent () override
NetworkType	nettype () const override
void	hardForkInfo (uint8_t &version, uint64_t &earliest_height) const override
	returns current hard fork info
bool	useForkRules (uint8_t version, int64_t early_blocks) const override
	check if hard fork rules should be used
void	addSubaddressAccount (const std::string &label) override
	addSubaddressAccount - appends a new subaddress account at the end of the last major index of existing subaddress accounts
size_t	numSubaddressAccounts () const override
	numSubaddressAccounts - returns the number of existing subaddress accounts
size_t	numSubaddresses (uint32_t accountIndex) const override
	numSubaddresses - returns the number of existing subaddresses associated with the specified subaddress account
void	addSubaddress (uint32_t accountIndex, const std::string &label) override
	addSubaddress - appends a new subaddress at the end of the last minor index of the specified subaddress account
std::string	getSubaddressLabel (uint32_t accountIndex, uint32_t addressIndex) const override
	getSubaddressLabel - gets the label of the specified subaddress
void	setSubaddressLabel (uint32_t accountIndex, uint32_t addressIndex, const std::string &label) override
	setSubaddressLabel - sets the label of the specified subaddress
MultisigState	multisig () const override
	multisig - returns current state of multisig wallet creation process
std::string	getMultisigInfo () const override
	getMultisigInfo
std::string	makeMultisig (const std::vector< std::string > &info, uint32_t threshold) override
	makeMultisig - switches wallet in multisig state. The one and only creation phase for N / N wallets
std::string	exchangeMultisigKeys (const std::vector< std::string > &info) override
	exchange_multisig_keys - provides additional key exchange round for arbitrary multisig schemes (like N-1/N, M/N)
bool	finalizeMultisig (const std::vector< std::string > &extraMultisigInfo) override
	finalizeMultisig - finalizes N - 1 / N multisig wallets creation
bool	exportMultisigImages (std::string &images) override
	exportMultisigImages - exports transfers' key images
size_t	importMultisigImages (const std::vector< std::string > &images) override
	importMultisigImages - imports other participants' multisig images
bool	hasMultisigPartialKeyImages () const override
	hasMultisigPartialKeyImages - checks if wallet needs to import multisig key images from other participants
PendingTransaction *	restoreMultisigTransaction (const std::string &signData) override
	restoreMultisigTransaction creates PendingTransaction from signData
PendingTransaction *	createTransaction (const std::string &dst_addr, const std::string &payment_id, optional< uint64_t > amount, uint32_t mixin_count, PendingTransaction::Priority priority=PendingTransaction::Priority_Low, uint32_t subaddr_account=0, std::set< uint32_t > subaddr_indices={}) override
	createTransaction creates transaction. if dst_addr is an integrated address, payment_id is ignored
virtual PendingTransaction *	createSweepUnmixableTransaction () override
	createSweepUnmixableTransaction creates transaction with unmixable outputs.
bool	submitTransaction (const std::string &fileName) override
	submitTransaction - submits transaction in signed tx file
virtual UnsignedTransaction *	loadUnsignedTx (const std::string &unsigned_filename) override
	loadUnsignedTx - creates transaction from unsigned tx file
bool	exportKeyImages (const std::string &filename) override
	exportKeyImages - exports key images to file
bool	importKeyImages (const std::string &filename) override
	importKeyImages - imports key images from file
virtual void	disposeTransaction (PendingTransaction *t) override
	disposeTransaction - destroys transaction object
virtual TransactionHistory *	history () override
virtual AddressBook *	addressBook () override
virtual Subaddress *	subaddress () override
virtual SubaddressAccount *	subaddressAccount () override
virtual void	setListener (WalletListener *l) override
virtual uint32_t	defaultMixin () const override
	defaultMixin - returns number of mixins used in transactions
virtual void	setDefaultMixin (uint32_t arg) override
	setDefaultMixin - setum number of mixins to be used for new transactions
virtual bool	setUserNote (const std::string &txid, const std::string &note) override
	setUserNote - attach an arbitrary string note to a txid
virtual std::string	getUserNote (const std::string &txid) const override
	getUserNote - return an arbitrary string note attached to a txid
virtual std::string	getTxKey (const std::string &txid) const override
virtual bool	checkTxKey (const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) override
virtual std::string	getTxProof (const std::string &txid, const std::string &address, const std::string &message) const override
virtual bool	checkTxProof (const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) override
virtual std::string	getSpendProof (const std::string &txid, const std::string &message) const override
virtual bool	checkSpendProof (const std::string &txid, const std::string &message, const std::string &signature, bool &good) const override
virtual std::string	getReserveProof (bool all, uint32_t account_index, uint64_t amount, const std::string &message) const override
	getReserveProof - Generates a proof that proves the reserve of unspent funds Parameters account_index and amount are ignored when all is true
virtual bool	checkReserveProof (const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const override
virtual std::string	signMessage (const std::string &message) override
virtual bool	verifySignedMessage (const std::string &message, const std::string &address, const std::string &signature) const override
	verifySignedMessage - verify a signature matches a given message
virtual std::string	signMultisigParticipant (const std::string &message) const override
	signMultisigParticipant signs given message with the multisig public signer key
virtual bool	verifyMessageWithPublicKey (const std::string &message, const std::string &publicKey, const std::string &signature) const override
	verifyMessageWithPublicKey verifies that message was signed with the given public key
virtual void	startRefresh () override
	StartRefresh - Start/resume refresh thread (refresh every 10 seconds).
virtual void	pauseRefresh () override
	pauseRefresh - pause refresh thread
virtual 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) override
virtual std::string	getDefaultDataDir () const override
virtual bool	lightWalletLogin (bool &isNewWallet) const override
	Light wallet authenticate and login.
virtual bool	lightWalletImportWalletRequest (std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) override
	Initiates a light wallet import wallet request.
virtual bool	blackballOutputs (const std::vector< std::string > &outputs, bool add) override
	blackballs a set of outputs
virtual bool	blackballOutput (const std::string &amount, const std::string &offset) override
	blackballs an output
virtual bool	unblackballOutput (const std::string &amount, const std::string &offset) override
	unblackballs an output
virtual bool	getRing (const std::string &key_image, std::vector< uint64_t > &ring) const override
	gets the ring used for a key image, if any
virtual bool	getRings (const std::string &txid, std::vector< std::pair< std::string, std::vector< uint64_t > > > &rings) const override
	gets the rings used for a txid, if any
virtual bool	setRing (const std::string &key_image, const std::vector< uint64_t > &ring, bool relative) override
	sets the ring used for a key image
virtual void	segregatePreForkOutputs (bool segregate) override
	sets whether pre-fork outs are to be segregated
virtual void	segregationHeight (uint64_t height) override
	sets the height where segregation should occur
virtual void	keyReuseMitigation2 (bool mitigation) override
	secondary key reuse mitigation
virtual bool	lockKeysFile () override
	locks/unlocks the keys file; returns true on success
virtual bool	unlockKeysFile () override
virtual bool	isKeysFileLocked () override
	returns true if the keys file is locked
virtual uint64_t	coldKeyImageSync (uint64_t &spent, uint64_t &unspent) override
	cold-device protocol key image sync
Public Member Functions inherited from Electroneum::Wallet
virtual	~Wallet ()=0
std::string	mainAddress () const
bool	mainnet () const
bool	testnet () const
bool	stagenet () const
uint64_t	balanceAll (bool public_blockchain) const
uint64_t	unlockedBalanceAll (bool public_blockchain) const

Friends
class	PendingTransactionImpl
class	UnsignedTransactionImpl
class	TransactionHistoryImpl
struct	Wallet2CallbackImpl
class	AddressBookImpl
class	SubaddressImpl
class	SubaddressAccountImpl

Additional Inherited Members
Public Types inherited from Electroneum::Wallet
enum	Device { Device_Software = 0 , Device_Ledger = 1 , Device_Trezor = 2 }
enum	Status { Status_Ok , Status_Error , Status_Critical }
enum	ConnectionStatus { ConnectionStatus_Disconnected , ConnectionStatus_Connected , ConnectionStatus_WrongVersion }
Static Public Member Functions inherited from Electroneum::Wallet
static std::string	displayAmount (uint64_t amount)
static uint64_t	amountFromString (const std::string &amount)
static uint64_t	amountFromDouble (double amount)
static std::string	genPaymentId ()
static bool	paymentIdValid (const std::string &paiment_id)
static bool	addressValid (const std::string &str, NetworkType nettype)
static bool	addressValid (const std::string &str, bool testnet)
static bool	keyValid (const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error)
static bool	keyValid (const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error)
static std::string	paymentIdFromAddress (const std::string &str, NetworkType nettype)
static std::string	paymentIdFromAddress (const std::string &str, bool testnet)
static uint64_t	maximumAllowedAmount ()
static void	init (const char *argv0, const char *default_log_base_name)
static void	init (const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console)
static void	debug (const std::string &category, const std::string &str)
static void	info (const std::string &category, const std::string &str)
static void	warning (const std::string &category, const std::string &str)
static void	error (const std::string &category, const std::string &str)

Detailed Description

Definition at line 53 of file wallet.h.

Constructor & Destructor Documentation

WalletImpl()

Electroneum::WalletImpl::WalletImpl	(	NetworkType	nettype = MAINNET,
		uint64_t	kdf_rounds = 1 )

Definition at line 420 of file wallet.cpp.

    :m_wallet(nullptr)
    , m_status(Wallet::Status_Ok)
    , m_wallet2Callback(nullptr)
    , m_recoveringFromSeed(false)
    , m_recoveringFromDevice(false)
    , m_synchronized(false)
    , m_rebuildWalletCache(false)
    , m_is_connected(false)
    , m_refreshShouldRescan(false)
{
    m_wallet.reset(new tools::wallet2(static_cast<cryptonote::network_type>(nettype), kdf_rounds, true));
    m_history.reset(new TransactionHistoryImpl(this));
    m_wallet2Callback.reset(new Wallet2CallbackImpl(this));
    m_wallet->callback(m_wallet2Callback.get());
    m_refreshThreadDone = false;
    m_refreshEnabled = false;
    m_addressBook.reset(new AddressBookImpl(this));
    m_subaddress.reset(new SubaddressImpl(this));
    m_subaddressAccount.reset(new SubaddressAccountImpl(this));
 
 
    m_refreshIntervalMillis = DEFAULT_REFRESH_INTERVAL_MILLIS;
 
    m_refreshThread = boost::thread([this] () {
        this->refreshThreadFunc();
    });
 
}

Here is the call graph for this function:

~WalletImpl()

Electroneum::WalletImpl::~WalletImpl

(

)

Definition at line 450 of file wallet.cpp.

{
 
    LOG_PRINT_L1(__FUNCTION__);
    m_wallet->callback(NULL);
    // Pause refresh thread - prevents refresh from starting again
    pauseRefresh();
    // Close wallet - stores cache and stops ongoing refresh operation 
    close(false); // do not store wallet as part of the closing activities
    // Stop refresh thread
    stopRefresh();
 
    if (m_wallet2Callback->getListener()) {
      m_wallet2Callback->getListener()->onSetWallet(nullptr);
    }
 
    LOG_PRINT_L1(__FUNCTION__ << " finished");
}

Here is the call graph for this function:

Member Function Documentation

address()

std::string Electroneum::WalletImpl::address ( uint32_t accountIndex = 0, uint32_t addressIndex = 0 ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 860 of file wallet.cpp.

{
    return m_wallet->get_subaddress_as_str({accountIndex, addressIndex});
}

Here is the caller graph for this function:

addressBook()

AddressBook * Electroneum::WalletImpl::addressBook ( )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1679 of file wallet.cpp.

{
    return m_addressBook.get();
}

Here is the caller graph for this function:

addSubaddress()

void Electroneum::WalletImpl::addSubaddress ( uint32_t accountIndex, const std::string & label )

overridevirtual

addSubaddress - appends a new subaddress at the end of the last minor index of the specified subaddress account

Parameters

accountIndex	- the major index specifying the subaddress account
label	- the label for the new subaddress

Implements Electroneum::Wallet.

Definition at line 1218 of file wallet.cpp.

{
    m_wallet->add_subaddress(accountIndex, label);
}

addSubaddressAccount()

void Electroneum::WalletImpl::addSubaddressAccount ( const std::string & label )

overridevirtual

addSubaddressAccount - appends a new subaddress account at the end of the last major index of existing subaddress accounts

Parameters

label

- the label for the new account (which is the as the label of the primary address (accountIndex,0))

Implements Electroneum::Wallet.

Definition at line 1206 of file wallet.cpp.

{
    m_wallet->add_subaddress_account(label);
}

approximateBlockChainHeight()

uint64_t Electroneum::WalletImpl::approximateBlockChainHeight ( ) const

overridevirtual

approximateBlockChainHeight - returns approximate blockchain height calculated from date/time

Returns

Implements Electroneum::Wallet.

Definition at line 1013 of file wallet.cpp.

{
    return m_wallet->get_approximate_blockchain_height();
}

autoRefreshInterval()

int Electroneum::WalletImpl::autoRefreshInterval ( ) const

overridevirtual

autoRefreshInterval - returns automatic refresh interval in millis

Returns

Implements Electroneum::Wallet.

Definition at line 1118 of file wallet.cpp.

{
    return m_refreshIntervalMillis;
}

balance()

uint64_t Electroneum::WalletImpl::balance ( uint32_t accountIndex = 0, bool public_blockchain = false ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 996 of file wallet.cpp.

{
    return m_wallet->balance(accountIndex, public_blockchain);
}

blackballOutput()

bool Electroneum::WalletImpl::blackballOutput ( const std::string & amount, const std::string & offset )

overridevirtual

blackballs an output

Implements Electroneum::Wallet.

Definition at line 2298 of file wallet.cpp.

{
    uint64_t raw_amount, raw_offset;
    if (!epee::string_tools::get_xtype_from_string(raw_amount, amount))
    {
        setStatusError(tr("Failed to parse output amount"));
        return false;
    }
    if (!epee::string_tools::get_xtype_from_string(raw_offset, offset))
    {
        setStatusError(tr("Failed to parse output offset"));
        return false;
    }
    bool ret = m_wallet->blackball_output(std::make_pair(raw_amount, raw_offset));
    if (!ret)
    {
        setStatusError(tr("Failed to mark output as spent"));
        return false;
    }
    return true;
}

Here is the call graph for this function:

blackballOutputs()

bool Electroneum::WalletImpl::blackballOutputs ( const std::vector< std::string > & outputs, bool add )

overridevirtual

blackballs a set of outputs

Implements Electroneum::Wallet.

Definition at line 2260 of file wallet.cpp.

{
    std::vector<std::pair<uint64_t, uint64_t>> raw_outputs;
    raw_outputs.reserve(outputs.size());
    uint64_t amount = std::numeric_limits<uint64_t>::max(), offset, num_offsets;
    for (const std::string &str: outputs)
    {
        if (sscanf(str.c_str(), "@%" PRIu64, &amount) == 1)
          continue;
        if (amount == std::numeric_limits<uint64_t>::max())
        {
          setStatusError("First line is not an amount");
          return true;
        }
        if (sscanf(str.c_str(), "%" PRIu64 "*%" PRIu64, &offset, &num_offsets) == 2 && num_offsets <= std::numeric_limits<uint64_t>::max() - offset)
        {
          while (num_offsets--)
            raw_outputs.push_back(std::make_pair(amount, offset++));
        }
        else if (sscanf(str.c_str(), "%" PRIu64, &offset) == 1)
        {
          raw_outputs.push_back(std::make_pair(amount, offset));
        }
        else
        {
          setStatusError(tr("Invalid output: ") + str);
          return false;
        }
    }
    bool ret = m_wallet->set_blackballed_outputs(raw_outputs, add);
    if (!ret)
    {
        setStatusError(tr("Failed to mark outputs as spent"));
        return false;
    }
    return true;
}

blockChainHeight()

uint64_t Electroneum::WalletImpl::blockChainHeight ( ) const

overridevirtual

blockChainHeight - returns current blockchain height

Returns

Implements Electroneum::Wallet.

Definition at line 1006 of file wallet.cpp.

{
    if(m_wallet->light_wallet()) {
        return m_wallet->get_light_wallet_scanned_block_height();
    }
    return m_wallet->get_blockchain_current_height();
}

checkReserveProof()

bool Electroneum::WalletImpl::checkReserveProof ( const std::string & address, const std::string & message, const std::string & signature, bool & good, uint64_t & total, uint64_t & spent ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1923 of file wallet.cpp.

                                                                                                                                                                     {
    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address))
    {
        setStatusError(tr("Failed to parse address"));
        return false;
    }
    if (info.is_subaddress)
    {
        setStatusError(tr("Address must not be a subaddress"));
        return false;
    }
 
    good = false;
    try
    {
        clearStatus();
        good = m_wallet->check_reserve_proof(info.address, message, signature, total, spent);
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

Here is the call graph for this function:

checkSpendProof()

bool Electroneum::WalletImpl::checkSpendProof ( const std::string & txid, const std::string & message, const std::string & signature, bool & good ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1883 of file wallet.cpp.

                                                                                                                                  {
    good = false;
    crypto::hash txid;
    if(!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return false;
    }
 
    try
    {
        clearStatus();
        good = m_wallet->check_spend_proof(txid, message, signature);
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

Here is the call graph for this function:

checkTxKey()

bool Electroneum::WalletImpl::checkTxKey ( const std::string & txid, std::string tx_key, const std::string & address, uint64_t & received, bool & in_pool, uint64_t & confirmations )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1758 of file wallet.cpp.

{
    crypto::hash txid;
    if (!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return false;
    }
 
    crypto::secret_key tx_key;
    std::vector<crypto::secret_key> additional_tx_keys;
    if (!epee::string_tools::hex_to_pod(tx_key_str.substr(0, 64), tx_key))
    {
        setStatusError(tr("Failed to parse tx key"));
        return false;
    }
    tx_key_str = tx_key_str.substr(64);
    while (!tx_key_str.empty())
    {
        additional_tx_keys.resize(additional_tx_keys.size() + 1);
        if (!epee::string_tools::hex_to_pod(tx_key_str.substr(0, 64), additional_tx_keys.back()))
        {
            setStatusError(tr("Failed to parse tx key"));
            return false;
        }
        tx_key_str = tx_key_str.substr(64);
    }
 
    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address_str))
    {
        setStatusError(tr("Failed to parse address"));
        return false;
    }
 
    try
    {
        m_wallet->check_tx_key(txid, tx_key, additional_tx_keys, info.address, received, in_pool, confirmations);
        clearStatus();
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

Here is the call graph for this function:

checkTxProof()

bool Electroneum::WalletImpl::checkTxProof ( const std::string & txid, const std::string & address, const std::string & message, const std::string & signature, bool & good, uint64_t & received, bool & in_pool, uint64_t & confirmations )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1834 of file wallet.cpp.

{
    crypto::hash txid;
    if (!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return false;
    }
 
    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address_str))
    {
        setStatusError(tr("Failed to parse address"));
        return false;
    }
 
    try
    {
        good = m_wallet->check_tx_proof(txid, info.address, info.is_subaddress, message, signature, received, in_pool, confirmations);
        clearStatus();
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

Here is the call graph for this function:

close()

bool Electroneum::WalletImpl::close

(

bool

store = true

)

Definition at line 762 of file wallet.cpp.

{
 
    bool result = false;
    LOG_PRINT_L1("closing wallet...");
    try {
        if (store) {
            // Do not store wallet with invalid status
            // Status Critical refers to errors on opening or creating wallets.
            if (status() != Status_Critical)
                m_wallet->store();
            else
                LOG_ERROR("Status_Critical - not saving wallet");
            LOG_PRINT_L1("wallet::store done");
        }
        LOG_PRINT_L1("Calling wallet::stop...");
        m_wallet->stop();
        LOG_PRINT_L1("wallet::stop done");
        m_wallet->deinit();
        result = true;
        clearStatus();
    } catch (const std::exception &e) {
        setStatusCritical(e.what());
        LOG_ERROR("Error closing wallet: " << e.what());
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

coldKeyImageSync()

uint64_t Electroneum::WalletImpl::coldKeyImageSync ( uint64_t & spent, uint64_t & unspent )

overridevirtual

cold-device protocol key image sync

Implements Electroneum::Wallet.

Definition at line 2428 of file wallet.cpp.

{
    return m_wallet->cold_key_image_sync(spent, unspent);
}

connected()

Wallet::ConnectionStatus Electroneum::WalletImpl::connected ( ) const

overridevirtual

connected - checks if the wallet connected to the daemon

Returns

- true if connected

Implements Electroneum::Wallet.

Definition at line 2021 of file wallet.cpp.

{
    uint32_t version = 0;
    m_is_connected = m_wallet->check_connection(&version, NULL, DEFAULT_CONNECTION_TIMEOUT_MILLIS);
    if (!m_is_connected)
        return Wallet::ConnectionStatus_Disconnected;
    // Version check is not implemented in light wallets nodes/wallets
    if (!m_wallet->light_wallet() && (version >> 16) != CORE_RPC_VERSION_MAJOR)
        return Wallet::ConnectionStatus_WrongVersion;
    return Wallet::ConnectionStatus_Connected;
}

connectToDaemon()

bool Electroneum::WalletImpl::connectToDaemon ( )

overridevirtual

connectToDaemon - connects to the daemon. TODO: check if it can be removed

Returns

Implements Electroneum::Wallet.

Definition at line 2009 of file wallet.cpp.

{
    bool result = m_wallet->check_connection(NULL, NULL, DEFAULT_CONNECTION_TIMEOUT_MILLIS);
    if (!result) {
        setStatusError("Error connecting to daemon at " + m_wallet->get_daemon_address());
    } else {
        clearStatus();
        // start refreshing here
    }
    return result;
}

create()

bool Electroneum::WalletImpl::create	(	const std::string &	path,
		const std::string &	password,
		const std::string &	language )

Definition at line 469 of file wallet.cpp.

{
 
    clearStatus();
    m_recoveringFromSeed = false;
    m_recoveringFromDevice = false;
    bool keys_file_exists;
    bool wallet_file_exists;
    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
    LOG_PRINT_L3("wallet_path: " << path << "");
    LOG_PRINT_L3("keys_file_exists: " << std::boolalpha << keys_file_exists << std::noboolalpha
                 << "  wallet_file_exists: " << std::boolalpha << wallet_file_exists << std::noboolalpha);
 
 
    // add logic to error out if new wallet requested but named wallet file exists
    if (keys_file_exists || wallet_file_exists) {
        std::string error = "attempting to generate or restore wallet, but specified file(s) exist.  Exiting to not risk overwriting.";
        LOG_ERROR(error);
        setStatusCritical(error);
        return false;
    }
    // TODO: validate language
    m_wallet->set_seed_language(language);
    crypto::secret_key recovery_val, secret_key;
    try {
        recovery_val = m_wallet->generate(path, password, secret_key, false, false);
        m_password = password;
        clearStatus();
    } catch (const std::exception &e) {
        LOG_ERROR("Error creating wallet: " << e.what());
        setStatusCritical(e.what());
        return false;
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createSweepUnmixableTransaction()

PendingTransaction * Electroneum::WalletImpl::createSweepUnmixableTransaction ( )

overridevirtual

createSweepUnmixableTransaction creates transaction with unmixable outputs.

Returns

PendingTransaction object. caller is responsible to check PendingTransaction::status() after object returned

Implements Electroneum::Wallet.

Definition at line 1587 of file wallet.cpp.

{
    clearStatus();
    cryptonote::tx_destination_entry de;
 
    PendingTransactionImpl * transaction = new PendingTransactionImpl(*this);
 
    do {
        try {
            transaction->m_pending_tx = m_wallet->create_unmixable_sweep_transactions();
            pendingTxPostProcess(transaction);
 
        } catch (const tools::error::daemon_busy&) {
            // TODO: make it translatable with "tr"?
            setStatusError(tr("daemon is busy. Please try again later."));
        } catch (const tools::error::no_connection_to_daemon&) {
            setStatusError(tr("no connection to daemon. Please make sure daemon is running."));
        } catch (const tools::error::wallet_rpc_error& e) {
            setStatusError(tr("RPC error: ") +  e.to_string());
        } catch (const tools::error::get_outs_error&) {
            setStatusError(tr("failed to get outputs to mix"));
        } catch (const tools::error::not_enough_unlocked_etn& e) {
            setStatusError("");
            std::ostringstream writer;
 
            writer << boost::format(tr("not enough ETN to transfer, available only %s, sent amount %s")) %
                      print_etn(e.available()) %
                      print_etn(e.tx_amount());
            setStatusError(writer.str());
        } catch (const tools::error::not_enough_etn& e) {
            setStatusError("");
            std::ostringstream writer;
 
            writer << boost::format(tr("not enough ETN to transfer, overall balance only %s, sent amount %s")) %
                      print_etn(e.available()) %
                      print_etn(e.tx_amount());
            setStatusError(writer.str());
        } catch (const tools::error::tx_not_possible& e) {
            setStatusError("");
            std::ostringstream writer;
 
            writer << boost::format(tr("not enough ETN to transfer, available only %s, transaction amount %s = %s + %s (fee)")) %
                      print_etn(e.available()) %
                      print_etn(e.tx_amount() + e.fee())  %
                      print_etn(e.tx_amount()) %
                      print_etn(e.fee());
            setStatusError(writer.str());
        } catch (const tools::error::not_enough_outs_to_mix& e) {
            std::ostringstream writer;
            writer << tr("not enough outputs.");
            for (const std::pair<uint64_t, uint64_t> outs_for_amount : e.scanty_outs()) {
                writer << "\n" << tr("output amount") << " = " << print_etn(outs_for_amount.first) << ", " << tr("found outputs to use") << " = " << outs_for_amount.second;
            }
            setStatusError(writer.str());
        } catch (const tools::error::tx_not_constructed&) {
            setStatusError(tr("transaction was not constructed"));
        } catch (const tools::error::tx_rejected& e) {
            std::ostringstream writer;
            writer << (boost::format(tr("transaction %s was rejected by daemon with status: ")) % get_transaction_hash(e.tx())) <<  e.status();
            setStatusError(writer.str());
        } catch (const tools::error::tx_sum_overflow& e) {
            setStatusError(e.what());
        } catch (const tools::error::zero_destination&) {
            setStatusError(tr("one of destinations is zero"));
        } catch (const tools::error::tx_too_big& e) {
            setStatusError(tr("failed to find a suitable way to split transactions"));
        } catch (const tools::error::transfer_error& e) {
            setStatusError(string(tr("unknown transfer error: ")) + e.what());
        } catch (const tools::error::wallet_internal_error& e) {
            setStatusError(string(tr("internal error: ")) + e.what());
        } catch (const std::exception& e) {
            setStatusError(string(tr("unexpected error: ")) + e.what());
        } catch (...) {
            setStatusError(tr("unknown error"));
        }
    } while (false);
 
    statusWithErrorString(transaction->m_status, transaction->m_errorString);
    return transaction;
}

Here is the call graph for this function:

createTransaction()

PendingTransaction * Electroneum::WalletImpl::createTransaction ( const std::string & dst_addr, const std::string & payment_id, optional< uint64_t > amount, uint32_t mixin_count, PendingTransaction::Priority = PendingTransaction::Priority_Low, uint32_t subaddr_account = 0, std::set< uint32_t > subaddr_indices = {} )

overridevirtual

createTransaction creates transaction. if dst_addr is an integrated address, payment_id is ignored

Parameters

dst_addr	destination address as string
payment_id	optional payment_id, can be empty string
amount	amount
mixin_count	mixin count. if 0 passed, wallet will use default value
subaddr_account	subaddress account from which the input funds are taken
subaddr_indices	set of subaddress indices to use for transfer or sweeping. if set empty, all are chosen when sweeping, and one or more are automatically chosen when transferring. after execution, returns the set of actually used indices
priority

Returns

PendingTransaction object. caller is responsible to check PendingTransaction::status() after object returned

Implements Electroneum::Wallet.

Definition at line 1412 of file wallet.cpp.

{
    clearStatus();
    // Pause refresh thread while creating transaction
    pauseRefresh();
      
    cryptonote::address_parse_info info;
 
    // indicates if dst_addr is integrated address (address + payment_id)
    // TODO:  (https://bitcointalk.org/index.php?topic=753252.msg9985441#msg9985441)
    size_t fake_outs_count = mixin_count > 0 ? mixin_count : m_wallet->default_mixin();
    if (fake_outs_count == 0)
        fake_outs_count = DEFAULT_MIXIN;
    fake_outs_count = m_wallet->adjust_mixin(fake_outs_count);
 
    uint32_t adjusted_priority = m_wallet->adjust_priority(static_cast<uint32_t>(priority));
 
    PendingTransactionImpl * transaction = new PendingTransactionImpl(*this);
 
    do {
        if(!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), dst_addr)) {
            // TODO: copy-paste 'if treating as an address fails, try as url' from simplewallet.cpp:1982
            setStatusError(tr("Invalid destination address"));
            break;
        }
 
 
        std::vector<uint8_t> extra;
        // if dst_addr is not an integrated address, parse payment_id
        if (!info.has_payment_id && !payment_id.empty()) {
            // copy-pasted from simplewallet.cpp:2212
            crypto::hash payment_id_long;
            bool r = tools::wallet2::parse_long_payment_id(payment_id, payment_id_long);
            if (r) {
                std::string extra_nonce;
                cryptonote::set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id_long);
                r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
            } else {
                r = tools::wallet2::parse_short_payment_id(payment_id, info.payment_id);
                if (r) {
                    std::string extra_nonce;
                    crypto::hash payment_id = crypto::null_hash;
                    memcpy(payment_id.data, info.payment_id.data, 8); // convert short pid to regular
                    memset(payment_id.data + 8, 0, 24); // merely a sanity check
 
                    set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
                    r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
                }
            }
 
            if (!r) {
                setStatusError(tr("payment id has invalid format, expected 16 or 64 character hex string: ") + payment_id);
                break;
            }
        }
        else if (info.has_payment_id) {
            std::string extra_nonce;
            crypto::hash payment_id = crypto::null_hash;
            memcpy(payment_id.data, info.payment_id.data, 8); // convert short pid to regular
            memset(payment_id.data + 8, 0, 24); // merely a sanity check
 
            set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
            bool r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
            if (!r) {
                setStatusError(tr("Failed to add short payment id: ") + epee::string_tools::pod_to_hex(info.payment_id));
                break;
            }
        }
 
 
        //std::vector<tools::wallet2::pending_tx> ptx_vector;
 
        try {
            if (amount) {
                vector<cryptonote::tx_destination_entry> dsts;
                cryptonote::tx_destination_entry de;
                de.original = dst_addr;
                de.addr = info.address;
                de.amount = *amount;
                de.is_subaddress = info.is_subaddress;
                de.is_integrated = info.has_payment_id;
                dsts.push_back(de);
                transaction->m_pending_tx = m_wallet->create_transactions_2(dsts, fake_outs_count, 0 /* unlock_time */,
                                                                          adjusted_priority,
                                                                          extra, subaddr_account, subaddr_indices);
            } else {
                // for the GUI, sweep_all (i.e. amount set as "(all)") will always sweep all the funds in all the addresses
                if (subaddr_indices.empty())
                {
                    for (uint32_t index = 0; index < m_wallet->get_num_subaddresses(subaddr_account); ++index)
                        subaddr_indices.insert(index);
                }
                transaction->m_pending_tx = m_wallet->create_transactions_all(0, info.address, info.is_subaddress, 1, fake_outs_count, 0 /* unlock_time */,
                                                                          adjusted_priority,
                                                                          extra, subaddr_account, subaddr_indices);
            }
 
            pendingTxPostProcess(transaction);
 
            if (multisig().isMultisig) {
                auto tx_set = m_wallet->make_multisig_tx_set(transaction->m_pending_tx);
                transaction->m_pending_tx = tx_set.m_ptx;
                transaction->m_signers = tx_set.m_signers;
            }
        } catch (const tools::error::daemon_busy&) {
            // TODO: make it translatable with "tr"?
            setStatusError(tr("daemon is busy. Please try again later."));
        } catch (const tools::error::no_connection_to_daemon&) {
            setStatusError(tr("no connection to daemon. Please make sure daemon is running."));
        } catch (const tools::error::wallet_rpc_error& e) {
            setStatusError(tr("RPC error: ") +  e.to_string());
        } catch (const tools::error::get_outs_error &e) {
            setStatusError((boost::format(tr("failed to get outputs to mix: %s")) % e.what()).str());
        } catch (const tools::error::not_enough_unlocked_etn& e) {
            std::ostringstream writer;
 
            writer << boost::format(tr("not enough ETN to transfer, available only %s, sent amount %s")) %
                      print_etn(e.available()) %
                      print_etn(e.tx_amount());
            setStatusError(writer.str());
        } catch (const tools::error::not_enough_etn& e) {
            std::ostringstream writer;
 
            writer << boost::format(tr("not enough ETN to transfer, overall balance only %s, sent amount %s")) %
                      print_etn(e.available()) %
                      print_etn(e.tx_amount());
            setStatusError(writer.str());
        } catch (const tools::error::tx_not_possible& e) {
            std::ostringstream writer;
 
            writer << boost::format(tr("not enough ETN to transfer, available only %s, transaction amount %s = %s + %s (fee)")) %
                      print_etn(e.available()) %
                      print_etn(e.tx_amount() + e.fee())  %
                      print_etn(e.tx_amount()) %
                      print_etn(e.fee());
            setStatusError(writer.str());
        } catch (const tools::error::not_enough_outs_to_mix& e) {
            std::ostringstream writer;
            writer << tr("not enough outputs.");
            for (const std::pair<uint64_t, uint64_t> outs_for_amount : e.scanty_outs()) {
                writer << "\n" << tr("output amount") << " = " << print_etn(outs_for_amount.first) << ", " << tr("found outputs to use") << " = " << outs_for_amount.second;
            }
            writer << "\n" << tr("Please sweep unmixable outputs.");
            setStatusError(writer.str());
        } catch (const tools::error::tx_not_constructed&) {
            setStatusError(tr("transaction was not constructed"));
        } catch (const tools::error::tx_rejected& e) {
            std::ostringstream writer;
            writer << (boost::format(tr("transaction %s was rejected by daemon with status: ")) % get_transaction_hash(e.tx())) <<  e.status();
            setStatusError(writer.str());
        } catch (const tools::error::tx_sum_overflow& e) {
            setStatusError(e.what());
        } catch (const tools::error::zero_destination&) {
            setStatusError(tr("one of destinations is zero"));
        } catch (const tools::error::tx_too_big& e) {
            setStatusError(tr("failed to find a suitable way to split transactions"));
        } catch (const tools::error::transfer_error& e) {
            setStatusError(string(tr("unknown transfer error: ")) + e.what());
        } catch (const tools::error::wallet_internal_error& e) {
            setStatusError(string(tr("internal error: ")) + e.what());
        } catch (const std::exception& e) {
            setStatusError(string(tr("unexpected error: ")) + e.what());
        } catch (...) {
            setStatusError(tr("unknown error"));
        }
    } while (false);
 
    statusWithErrorString(transaction->m_status, transaction->m_errorString);
    // Resume refresh thread
    startRefresh();
    return transaction;
}

Here is the call graph for this function:

createWatchOnly()

bool Electroneum::WalletImpl::createWatchOnly ( const std::string & path, const std::string & password, const std::string & language ) const

overridevirtual

createWatchOnly - Creates a watch only wallet

Parameters

path	- where to store the wallet
password
language

Returns

- true if created successfully

Implements Electroneum::Wallet.

Definition at line 506 of file wallet.cpp.

{
    clearStatus();
    std::unique_ptr<tools::wallet2> view_wallet(new tools::wallet2(m_wallet->nettype()));
 
    // Store same refresh height as original wallet
    view_wallet->set_refresh_from_block_height(m_wallet->get_refresh_from_block_height());
 
    bool keys_file_exists;
    bool wallet_file_exists;
    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
    LOG_PRINT_L3("wallet_path: " << path << "");
    LOG_PRINT_L3("keys_file_exists: " << std::boolalpha << keys_file_exists << std::noboolalpha
                 << "  wallet_file_exists: " << std::boolalpha << wallet_file_exists << std::noboolalpha);
 
    // add logic to error out if new wallet requested but named wallet file exists
    if (keys_file_exists || wallet_file_exists) {
        std::string error = "attempting to generate view only wallet, but specified file(s) exist.  Exiting to not risk overwriting.";
        LOG_ERROR(error);
        setStatusError(error);
        return false;
    }
    // TODO: validate language
    view_wallet->set_seed_language(language);
 
    const crypto::secret_key viewkey = m_wallet->get_account().get_keys().m_view_secret_key;
    const cryptonote::account_public_address address = m_wallet->get_account().get_keys().m_account_address;
 
    try {
        // Generate view only wallet
        view_wallet->generate(path, password, address, viewkey);
 
        // Export/Import outputs
        auto outputs = m_wallet->export_outputs();
        view_wallet->import_outputs(outputs);
 
        // Copy scanned blockchain
        auto bc = m_wallet->export_blockchain();
        view_wallet->import_blockchain(bc);
 
        // copy payments
        auto payments = m_wallet->export_payments();
        view_wallet->import_payments(payments);
 
        // copy confirmed outgoing payments
        std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>> out_payments;
        m_wallet->get_payments_out(out_payments, 0);
        view_wallet->import_payments_out(out_payments);
 
        // Export/Import key images
        // We already know the spent status from the outputs we exported, thus no need to check them again
        auto key_images = m_wallet->export_key_images();
        uint64_t spent = 0;
        uint64_t unspent = 0;
        view_wallet->import_key_images(key_images.second, key_images.first, spent, unspent, false);
        clearStatus();
    } catch (const std::exception &e) {
        LOG_ERROR("Error creating view only wallet: " << e.what());
        setStatusError(e.what());
        return false;
    }
    // Store wallet
    view_wallet->store();
    return true;
}

Here is the call graph for this function:

daemonBlockChainHeight()

uint64_t Electroneum::WalletImpl::daemonBlockChainHeight ( ) const

overridevirtual

daemonBlockChainHeight - returns daemon blockchain height

Returns

0 - in case error communicating with the daemon. status() will return Status_Error and errorString() will return verbose error description

Implements Electroneum::Wallet.

Definition at line 1023 of file wallet.cpp.

{
    if(m_wallet->light_wallet()) {
        return m_wallet->get_light_wallet_scanned_block_height();
    }
    if (!m_is_connected)
        return 0;
    std::string err;
    uint64_t result = m_wallet->get_daemon_blockchain_height(err);
    if (!err.empty()) {
        LOG_ERROR(__FUNCTION__ << ": " << err);
        result = 0;
        setStatusError(err);
    } else {
        clearStatus();
    }
    return result;
}

Here is the caller graph for this function:

daemonBlockChainTargetHeight()

uint64_t Electroneum::WalletImpl::daemonBlockChainTargetHeight ( ) const

overridevirtual

daemonBlockChainTargetHeight - returns daemon blockchain target height

Returns

0 - in case error communicating with the daemon. status() will return Status_Error and errorString() will return verbose error description

Implements Electroneum::Wallet.

Definition at line 1042 of file wallet.cpp.

{
    if(m_wallet->light_wallet()) {
        return m_wallet->get_light_wallet_blockchain_height();
    }
    if (!m_is_connected)
        return 0;
    std::string err;
    uint64_t result = m_wallet->get_daemon_blockchain_target_height(err);
    if (!err.empty()) {
        LOG_ERROR(__FUNCTION__ << ": " << err);
        result = 0;
        setStatusError(err);
    } else {
        clearStatus();
    }
    // Target height can be 0 when daemon is synced. Use blockchain height instead. 
    if(result == 0)
        result = daemonBlockChainHeight();
    return result;
}

Here is the call graph for this function:

defaultMixin()

uint32_t Electroneum::WalletImpl::defaultMixin ( ) const

overridevirtual

defaultMixin - returns number of mixins used in transactions

Returns

Implements Electroneum::Wallet.

Definition at line 1700 of file wallet.cpp.

{
    return m_wallet->default_mixin();
}

disposeTransaction()

void Electroneum::WalletImpl::disposeTransaction ( PendingTransaction * t )

overridevirtual

disposeTransaction - destroys transaction object

Parameters

t	- pointer to the "PendingTransaction" object. Pointer is not valid after function returned;

Implements Electroneum::Wallet.

Definition at line 1669 of file wallet.cpp.

{
    delete t;
}

errorString()

std::string Electroneum::WalletImpl::errorString ( ) const

overridevirtual

in case error status, returns error string

Implements Electroneum::Wallet.

Definition at line 814 of file wallet.cpp.

{
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    return m_errorString;
}

Here is the caller graph for this function:

estimateBlockChainHeight()

uint64_t Electroneum::WalletImpl::estimateBlockChainHeight ( ) const

overridevirtual

estimateBlockChainHeight - returns estimate blockchain height. More accurate than approximateBlockChainHeight, uses daemon height and falls back to calculation from date/time

Returns

Implements Electroneum::Wallet.

Definition at line 1018 of file wallet.cpp.

{
    return m_wallet->estimate_blockchain_height();
}

Here is the caller graph for this function:

exchangeMultisigKeys()

std::string Electroneum::WalletImpl::exchangeMultisigKeys ( const std::vector< std::string > & info )

overridevirtual

exchange_multisig_keys - provides additional key exchange round for arbitrary multisig schemes (like N-1/N, M/N)

Parameters

info	- base58 encoded key derivations returned by makeMultisig or exchangeMultisigKeys function call

Returns

new info string if more rounds required or an empty string if wallet creation is done

Implements Electroneum::Wallet.

Definition at line 1284 of file wallet.cpp.

                                                                           {
    try {
        clearStatus();
        checkMultisigWalletNotReady(m_wallet);
 
        return m_wallet->exchange_multisig_keys(epee::wipeable_string(m_password), info);
    } catch (const exception& e) {
        LOG_ERROR("Error on exchanging multisig keys: " << e.what());
        setStatusError(string(tr("Failed to make multisig: ")) + e.what());
    }
 
    return string();
}

Here is the call graph for this function:

exportKeyImages()

bool Electroneum::WalletImpl::exportKeyImages ( const std::string & filename )

overridevirtual

exportKeyImages - exports key images to file

Parameters

filename

Returns

- true on success

Implements Electroneum::Wallet.

Definition at line 1158 of file wallet.cpp.

{
  if (m_wallet->watch_only())
  {
    setStatusError(tr("Wallet is view only"));
    return false;
  }
  
  try
  {
    if (!m_wallet->export_key_images(filename))
    {
      setStatusError(tr("failed to save file ") + filename);
      return false;
    }
  }
  catch (const std::exception &e)
  {
    LOG_ERROR("Error exporting key images: " << e.what());
    setStatusError(e.what());
    return false;
  }
  return true;
}

Here is the call graph for this function:

exportMultisigImages()

bool Electroneum::WalletImpl::exportMultisigImages ( std::string & images )

overridevirtual

exportMultisigImages - exports transfers' key images

Parameters

images

- output paramter for hex encoded array of images

Returns

true if success

Implements Electroneum::Wallet.

Definition at line 1316 of file wallet.cpp.

                                                    {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);
 
        auto blob = m_wallet->export_multisig();
        images = epee::string_tools::buff_to_hex_nodelimer(blob);
        return true;
    } catch (const exception& e) {
        LOG_ERROR("Error on exporting multisig images: " << e.what());
        setStatusError(string(tr("Failed to export multisig images: ")) + e.what());
    }
 
    return false;
}

Here is the call graph for this function:

filename()

string Electroneum::WalletImpl::filename ( ) const

overridevirtual

filename - returns wallet filename

Returns

Implements Electroneum::Wallet.

Definition at line 927 of file wallet.cpp.

{
    return m_wallet->get_wallet_file();
}

Here is the caller graph for this function:

finalizeMultisig()

bool Electroneum::WalletImpl::finalizeMultisig ( const std::vector< std::string > & extraMultisigInfo )

overridevirtual

finalizeMultisig - finalizes N - 1 / N multisig wallets creation

Parameters

extraMultisigInfo

- wallet participants' extra multisig info obtained with makeMultisig call

Returns

true if success

Implements Electroneum::Wallet.

Definition at line 1298 of file wallet.cpp.

                                                                         {
    try {
        clearStatus();
        checkMultisigWalletNotReady(m_wallet);
 
        if (m_wallet->finalize_multisig(epee::wipeable_string(m_password), extraMultisigInfo)) {
            return true;
        }
 
        setStatusError(tr("Failed to finalize multisig wallet creation"));
    } catch (const exception& e) {
        LOG_ERROR("Error on finalizing multisig wallet creation: " << e.what());
        setStatusError(string(tr("Failed to finalize multisig wallet creation: ")) + e.what());
    }
 
    return false;
}

getDefaultDataDir()

std::string Electroneum::WalletImpl::getDefaultDataDir ( ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 2227 of file wallet.cpp.

{
 return tools::get_default_data_dir();
}

Here is the call graph for this function:

getDeviceType()

Wallet::Device Electroneum::WalletImpl::getDeviceType ( ) const

overridevirtual

Queries backing device for wallet keys.

Returns

Device they are on

Implements Electroneum::Wallet.

Definition at line 694 of file wallet.cpp.

{
    return static_cast<Wallet::Device>(m_wallet->get_device_type());
}

getMultisigInfo()

string Electroneum::WalletImpl::getMultisigInfo ( ) const

overridevirtual

getMultisigInfo

Returns

serialized and signed multisig info string

Implements Electroneum::Wallet.

Definition at line 1255 of file wallet.cpp.

                                         {
    try {
        clearStatus();
        return m_wallet->get_multisig_info();
    } catch (const exception& e) {
        LOG_ERROR("Error on generating multisig info: " << e.what());
        setStatusError(string(tr("Failed to get multisig info: ")) + e.what());
    }
 
    return string();
}

getRefreshFromBlockHeight()

uint64_t Electroneum::WalletImpl::getRefreshFromBlockHeight ( ) const

inlineoverridevirtual

getRestoreHeight - get wallet creation height

Implements Electroneum::Wallet.

Definition at line 126 of file wallet.h.

{ return m_wallet->get_refresh_from_block_height(); };

getReserveProof()

std::string Electroneum::WalletImpl::getReserveProof ( bool all, uint32_t account_index, uint64_t amount, const std::string & message ) const

overridevirtual

getReserveProof - Generates a proof that proves the reserve of unspent funds Parameters account_index and amount are ignored when all is true

Implements Electroneum::Wallet.

Definition at line 1905 of file wallet.cpp.

                                                                                                                       {
    try
    {
        clearStatus();
        boost::optional<std::pair<uint32_t, uint64_t>> account_minreserve;
        if (!all)
        {
            account_minreserve = std::make_pair(account_index, amount);
        }
        return m_wallet->get_reserve_proof(account_minreserve, message);
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return "";
    }
}

Here is the call graph for this function:

getRing()

bool Electroneum::WalletImpl::getRing ( const std::string & key_image, std::vector< uint64_t > & ring ) const

overridevirtual

gets the ring used for a key image, if any

Implements Electroneum::Wallet.

Definition at line 2342 of file wallet.cpp.

{
    crypto::key_image raw_key_image;
    if (!epee::string_tools::hex_to_pod(key_image, raw_key_image))
    {
        setStatusError(tr("Failed to parse key image"));
        return false;
    }
    bool ret = m_wallet->get_ring(raw_key_image, ring);
    if (!ret)
    {
        setStatusError(tr("Failed to get ring"));
        return false;
    }
    return true;
}

Here is the call graph for this function:

getRings()

bool Electroneum::WalletImpl::getRings ( const std::string & txid, std::vector< std::pair< std::string, std::vector< uint64_t > > > & rings ) const

overridevirtual

gets the rings used for a txid, if any

Implements Electroneum::Wallet.

Definition at line 2359 of file wallet.cpp.

{
    crypto::hash raw_txid;
    if (!epee::string_tools::hex_to_pod(txid, raw_txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return false;
    }
    std::vector<std::pair<crypto::key_image, std::vector<uint64_t>>> raw_rings;
    bool ret = m_wallet->get_rings(raw_txid, raw_rings);
    if (!ret)
    {
        setStatusError(tr("Failed to get rings"));
        return false;
    }
    for (const auto &r: raw_rings)
    {
      rings.push_back(std::make_pair(epee::string_tools::pod_to_hex(r.first), r.second));
    }
    return true;
}

Here is the call graph for this function:

getSeedLanguage()

std::string Electroneum::WalletImpl::getSeedLanguage ( ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 798 of file wallet.cpp.

{
    return m_wallet->get_seed_language();
}

getSpendProof()

std::string Electroneum::WalletImpl::getSpendProof ( const std::string & txid, const std::string & message ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1863 of file wallet.cpp.

                                                                                             {
    crypto::hash txid;
    if(!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return "";
    }
 
    try
    {
        clearStatus();
        return m_wallet->get_spend_proof(txid, message);
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return "";
    }
}

Here is the call graph for this function:

getSubaddressLabel()

std::string Electroneum::WalletImpl::getSubaddressLabel ( uint32_t accountIndex, uint32_t addressIndex ) const

overridevirtual

getSubaddressLabel - gets the label of the specified subaddress

Parameters

accountIndex	- the major index specifying the subaddress account
addressIndex	- the minor index specifying the subaddress

Implements Electroneum::Wallet.

Definition at line 1222 of file wallet.cpp.

{
    try
    {
        return m_wallet->get_subaddress_label({accountIndex, addressIndex});
    }
    catch (const std::exception &e)
    {
        LOG_ERROR("Error getting subaddress label: " << e.what());
        setStatusError(string(tr("Failed to get subaddress label: ")) + e.what());
        return "";
    }
}

getTxKey()

std::string Electroneum::WalletImpl::getTxKey ( const std::string & txid ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1731 of file wallet.cpp.

{
    crypto::hash txid;
    if(!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return "";
    }
 
    crypto::secret_key tx_key;
    std::vector<crypto::secret_key> additional_tx_keys;
    if (m_wallet->get_tx_key(txid, tx_key, additional_tx_keys))
    {
        clearStatus();
        std::ostringstream oss;
        oss << epee::string_tools::pod_to_hex(tx_key);
        for (size_t i = 0; i < additional_tx_keys.size(); ++i)
            oss << epee::string_tools::pod_to_hex(additional_tx_keys[i]);
        return oss.str();
    }
    else
    {
        setStatusError(tr("no tx keys found for this txid"));
        return "";
    }
}

Here is the call graph for this function:

getTxProof()

std::string Electroneum::WalletImpl::getTxProof ( const std::string & txid, const std::string & address, const std::string & message ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1806 of file wallet.cpp.

{
    crypto::hash txid;
    if (!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr("Failed to parse txid"));
        return "";
    }
 
    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address_str))
    {
        setStatusError(tr("Failed to parse address"));
        return "";
    }
 
    try
    {
        clearStatus();
        return m_wallet->get_tx_proof(txid, info.address, info.is_subaddress, message);
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return "";
    }
}

Here is the call graph for this function:

getUserNote()

std::string Electroneum::WalletImpl::getUserNote ( const std::string & txid ) const

overridevirtual

getUserNote - return an arbitrary string note attached to a txid

Parameters

txid	- the transaction id to attach the note to

Returns

the attached note, or empty string if there is none

Implements Electroneum::Wallet.

Definition at line 1721 of file wallet.cpp.

{
    cryptonote::blobdata txid_data;
    if(!epee::string_tools::parse_hexstr_to_binbuff(txid, txid_data) || txid_data.size() != sizeof(crypto::hash))
      return "";
    const crypto::hash htxid = *reinterpret_cast<const crypto::hash*>(txid_data.data());
 
    return m_wallet->get_tx_note(htxid);
}

Here is the call graph for this function:

hardForkInfo()

void Electroneum::WalletImpl::hardForkInfo ( uint8_t & version, uint64_t & earliest_height ) const

overridevirtual

returns current hard fork info

Implements Electroneum::Wallet.

Definition at line 2250 of file wallet.cpp.

{
    m_wallet->get_hard_fork_info(version, earliest_height);
}

hasMultisigPartialKeyImages()

bool Electroneum::WalletImpl::hasMultisigPartialKeyImages ( ) const

overridevirtual

hasMultisigPartialKeyImages - checks if wallet needs to import multisig key images from other participants

Returns

true if there are partial key images

Implements Electroneum::Wallet.

Definition at line 1360 of file wallet.cpp.

                                                   {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);
 
        return m_wallet->has_multisig_partial_key_images();
    } catch (const exception& e) {
        LOG_ERROR("Error on checking for partial multisig key images: " << e.what());
        setStatusError(string(tr("Failed to check for partial multisig key images: ")) + e.what());
    }
 
    return false;
}

history()

TransactionHistory * Electroneum::WalletImpl::history ( )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1674 of file wallet.cpp.

{
    return m_history.get();
}

importKeyImages()

bool Electroneum::WalletImpl::importKeyImages ( const std::string & filename )

overridevirtual

importKeyImages - imports key images from file

Parameters

filename

Returns

- true on success

Implements Electroneum::Wallet.

Definition at line 1183 of file wallet.cpp.

{
  if (!trustedDaemon()) {
    setStatusError(tr("Key images can only be imported with a trusted daemon"));
    return false;
  }
  try
  {
    uint64_t spent = 0, unspent = 0;
    uint64_t height = m_wallet->import_key_images(filename, spent, unspent);
    LOG_PRINT_L2("Signed key images imported to height " << height << ", "
        << print_etn(spent) << " spent, " << print_etn(unspent) << " unspent");
  }
  catch (const std::exception &e)
  {
    LOG_ERROR("Error exporting key images: " << e.what());
    setStatusError(string(tr("Failed to import key images: ")) + e.what());
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

importMultisigImages()

size_t Electroneum::WalletImpl::importMultisigImages ( const std::vector< std::string > & images )

overridevirtual

importMultisigImages - imports other participants' multisig images

Parameters

images

- array of hex encoded arrays of images obtained with exportMultisigImages

Returns

number of imported images

Implements Electroneum::Wallet.

Definition at line 1332 of file wallet.cpp.

                                                                    {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);
 
        std::vector<std::string> blobs;
        blobs.reserve(images.size());
 
        for (const auto& image: images) {
            std::string blob;
            if (!epee::string_tools::parse_hexstr_to_binbuff(image, blob)) {
                LOG_ERROR("Failed to parse imported multisig images");
                setStatusError(tr("Failed to parse imported multisig images"));
                return 0;
            }
 
            blobs.emplace_back(std::move(blob));
        }
 
        return m_wallet->import_multisig(blobs);
    } catch (const exception& e) {
        LOG_ERROR("Error on importing multisig images: " << e.what());
        setStatusError(string(tr("Failed to import multisig images: ")) + e.what());
    }
 
    return 0;
}

Here is the call graph for this function:

init()

bool Electroneum::WalletImpl::init ( const std::string & daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string & daemon_username = "", const std::string & daemon_password = "", bool use_ssl = false, bool lightWallet = false )

overridevirtual

init - initializes wallet with daemon connection params. if daemon_address is local address, "trusted daemon" will be set to true forcibly startRefresh() should be called when wallet is initialized.

Parameters

daemon_address	- daemon address in "hostname:port" format
upper_transaction_size_limit
daemon_username
daemon_password
lightWallet	- start wallet in light mode, connect to a openmonero compatible server.

Returns

- true on success

Implements Electroneum::Wallet.

Definition at line 937 of file wallet.cpp.

{
    clearStatus();
    m_wallet->set_light_wallet(lightWallet);
    if(daemon_username != "")
        m_daemon_login.emplace(daemon_username, daemon_password);
    return doInit(daemon_address, upper_transaction_size_limit, use_ssl);
}

integratedAddress()

std::string Electroneum::WalletImpl::integratedAddress ( const std::string & payment_id ) const

overridevirtual

integratedAddress - returns integrated address for current wallet address and given payment_id. if passed "payment_id" param is an empty string or not-valid payment id string (16 characters hexadecimal string) - random payment_id will be generated

Parameters

payment_id

- 16 characters hexadecimal string or empty string if new random payment id needs to be generated

Returns

- 106 characters string representing integrated address

Implements Electroneum::Wallet.

Definition at line 865 of file wallet.cpp.

{
    crypto::hash8 pid;
    if (!tools::wallet2::parse_short_payment_id(payment_id, pid)) {
        return "";
    }
    return m_wallet->get_integrated_address_as_str(pid);
}

Here is the call graph for this function:

isKeysFileLocked()

bool Electroneum::WalletImpl::isKeysFileLocked ( )

overridevirtual

returns true if the keys file is locked

Implements Electroneum::Wallet.

Definition at line 2423 of file wallet.cpp.

{
    return m_wallet->is_keys_file_locked();
}

keyReuseMitigation2()

void Electroneum::WalletImpl::keyReuseMitigation2 ( bool mitigation )

overridevirtual

secondary key reuse mitigation

Implements Electroneum::Wallet.

Definition at line 2408 of file wallet.cpp.

{
    m_wallet->key_reuse_mitigation2(mitigation);
}

keysFilename()

string Electroneum::WalletImpl::keysFilename ( ) const

overridevirtual

keysFilename - returns keys filename. usually this formed as "wallet_filename".keys

Returns

Implements Electroneum::Wallet.

Definition at line 932 of file wallet.cpp.

{
    return m_wallet->get_keys_file();
}

lightWalletImportWalletRequest()

bool Electroneum::WalletImpl::lightWalletImportWalletRequest ( std::string & payment_id, uint64_t & fee, bool & new_request, bool & request_fulfilled, std::string & payment_address, std::string & status )

overridevirtual

Initiates a light wallet import wallet request.

Implements Electroneum::Wallet.

Definition at line 951 of file wallet.cpp.

{
  try
  {
    tools::COMMAND_RPC_IMPORT_WALLET_REQUEST::response response;
    if(!m_wallet->light_wallet_import_wallet_request(response)){
      setStatusError(tr("Failed to send import wallet request"));
      return false;
    }
    fee = response.import_fee;
    payment_id = response.payment_id;
    new_request = response.new_request;
    request_fulfilled = response.request_fulfilled;
    payment_address = response.payment_address;
    status = response.status;
  }
  catch (const std::exception &e)
  {
    LOG_ERROR("Error sending import wallet request: " << e.what());
    setStatusError(e.what());
    return false;
  }
  return true;
}

Here is the call graph for this function:

lightWalletLogin()

bool Electroneum::WalletImpl::lightWalletLogin ( bool & isNewWallet ) const

overridevirtual

Light wallet authenticate and login.

Implements Electroneum::Wallet.

Definition at line 946 of file wallet.cpp.

{
  return m_wallet->light_wallet_login(isNewWallet);
}

loadUnsignedTx()

UnsignedTransaction * Electroneum::WalletImpl::loadUnsignedTx ( const std::string & unsigned_filename )

overridevirtual

loadUnsignedTx - creates transaction from unsigned tx file

Returns

- UnsignedTransaction object. caller is responsible to check UnsignedTransaction::status() after object returned

Implements Electroneum::Wallet.

Definition at line 1123 of file wallet.cpp.

                                                                                  {
  clearStatus();
  UnsignedTransactionImpl * transaction = new UnsignedTransactionImpl(*this);
  if (!m_wallet->load_unsigned_tx(unsigned_filename, transaction->m_unsigned_tx_set)){
    setStatusError(tr("Failed to load unsigned transactions"));
  }
  
  // Check tx data and construct confirmation message
  std::string extra_message;
  if (!transaction->m_unsigned_tx_set.transfers.second.empty())
    extra_message = (boost::format("%u outputs to import. ") % (unsigned)transaction->m_unsigned_tx_set.transfers.second.size()).str();
  transaction->checkLoadedTx([&transaction](){return transaction->m_unsigned_tx_set.txes.size();}, [&transaction](size_t n)->const tools::wallet2::tx_construction_data&{return transaction->m_unsigned_tx_set.txes[n];}, extra_message);
  setStatus(transaction->status(), transaction->errorString());
    
  return transaction;
}

Here is the call graph for this function:

lockKeysFile()

bool Electroneum::WalletImpl::lockKeysFile ( )

overridevirtual

locks/unlocks the keys file; returns true on success

Implements Electroneum::Wallet.

Definition at line 2413 of file wallet.cpp.

{
    return m_wallet->lock_keys_file();
}

makeMultisig()

string Electroneum::WalletImpl::makeMultisig ( const std::vector< std::string > & info, uint32_t threshold )

overridevirtual

makeMultisig - switches wallet in multisig state. The one and only creation phase for N / N wallets

Parameters

info	- vector of multisig infos from other participants obtained with getMulitisInfo call
threshold	- number of required signers to make valid transaction. Must be equal to number of participants (N) or N - 1

Returns

in case of N / N wallets returns empty string since no more key exchanges needed. For N - 1 / N wallets returns base58 encoded extra multisig info

Implements Electroneum::Wallet.

Definition at line 1267 of file wallet.cpp.

                                                                              {
    try {
        clearStatus();
 
        if (m_wallet->multisig()) {
            throw runtime_error("Wallet is already multisig");
        }
 
        return m_wallet->make_multisig(epee::wipeable_string(m_password), info, threshold);
    } catch (const exception& e) {
        LOG_ERROR("Error on making multisig wallet: " << e.what());
        setStatusError(string(tr("Failed to make multisig: ")) + e.what());
    }
 
    return string();
}

Here is the call graph for this function:

multisig()

MultisigState Electroneum::WalletImpl::multisig ( ) const

overridevirtual

multisig - returns current state of multisig wallet creation process

Returns

MultisigState struct

Implements Electroneum::Wallet.

Definition at line 1248 of file wallet.cpp.

                                         {
    MultisigState state;
    state.isMultisig = m_wallet->multisig(&state.isReady, &state.threshold, &state.total);
 
    return state;
}

Here is the caller graph for this function:

nettype()

NetworkType Electroneum::WalletImpl::nettype ( ) const

inlineoverridevirtual

Implements Electroneum::Wallet.

Definition at line 132 of file wallet.h.

{return static_cast<NetworkType>(m_wallet->nettype());}

Here is the caller graph for this function:

numSubaddressAccounts()

size_t Electroneum::WalletImpl::numSubaddressAccounts ( ) const

overridevirtual

numSubaddressAccounts - returns the number of existing subaddress accounts

Implements Electroneum::Wallet.

Definition at line 1210 of file wallet.cpp.

{
    return m_wallet->get_num_subaddress_accounts();
}

numSubaddresses()

size_t Electroneum::WalletImpl::numSubaddresses ( uint32_t accountIndex ) const

overridevirtual

numSubaddresses - returns the number of existing subaddresses associated with the specified subaddress account

Parameters

accountIndex

- the major index specifying the subaddress account

Implements Electroneum::Wallet.

Definition at line 1214 of file wallet.cpp.

{
    return m_wallet->get_num_subaddresses(accountIndex);
}

open()

bool Electroneum::WalletImpl::open	(	const std::string &	path,
		const std::string &	password )

Definition at line 699 of file wallet.cpp.

{
    clearStatus();
    m_recoveringFromSeed = false;
    m_recoveringFromDevice = false;
    try {
        // TODO: handle "deprecated"
        // Check if wallet cache exists
        bool keys_file_exists;
        bool wallet_file_exists;
        tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
        if(!wallet_file_exists){
            // Rebuilding wallet cache, using refresh height from .keys file
            m_rebuildWalletCache = true;
        }
        m_wallet->set_ring_database(get_default_ringdb_path(m_wallet->nettype()));
        m_wallet->load(path, password);
 
        m_password = password;
    } catch (const std::exception &e) {
        LOG_ERROR("Error opening wallet: " << e.what());
        setStatusCritical(e.what());
    }
    return status() == Status_Ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_uri()

bool Electroneum::WalletImpl::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 )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 2222 of file wallet.cpp.

{
    return m_wallet->parse_uri(uri, address, payment_id, amount, tx_description, recipient_name, unknown_parameters, error);
}

Here is the call graph for this function:

path()

std::string Electroneum::WalletImpl::path ( ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 904 of file wallet.cpp.

{
    return m_wallet->path();
}

Here is the caller graph for this function:

pauseRefresh()

void Electroneum::WalletImpl::pauseRefresh ( )

overridevirtual

pauseRefresh - pause refresh thread

Implements Electroneum::Wallet.

Definition at line 2161 of file wallet.cpp.

{
    LOG_PRINT_L2(__FUNCTION__ << ": refresh paused...");
    // TODO synchronize access
    if (!m_refreshThreadDone) {
        m_refreshEnabled = false;
    }
}

Here is the caller graph for this function:

publicMultisigSignerKey()

std::string Electroneum::WalletImpl::publicMultisigSignerKey ( ) const

overridevirtual

publicMultisigSignerKey - returns public signer key

Returns

- public multisignature signer key or empty string if wallet is not multisig

Implements Electroneum::Wallet.

Definition at line 894 of file wallet.cpp.

{
    try {
        crypto::public_key signer = m_wallet->get_multisig_signer_public_key();
        return epee::string_tools::pod_to_hex(signer);
    } catch (const std::exception&) {
        return "";
    }
}

Here is the call graph for this function:

publicSpendKey()

std::string Electroneum::WalletImpl::publicSpendKey ( ) const

overridevirtual

publicSpendKey - returns public spend key

Returns

- public spend key

Implements Electroneum::Wallet.

Definition at line 889 of file wallet.cpp.

{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_account_address.m_spend_public_key);
}

Here is the call graph for this function:

publicViewKey()

std::string Electroneum::WalletImpl::publicViewKey ( ) const

overridevirtual

publicViewKey - returns public view key

Returns

- public view key

Implements Electroneum::Wallet.

Definition at line 879 of file wallet.cpp.

{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_account_address.m_view_public_key);
}

Here is the call graph for this function:

recover() [1/2]

bool Electroneum::WalletImpl::recover	(	const std::string &	path,
		const std::string &	password,
		const std::string &	seed )

Definition at line 730 of file wallet.cpp.

{
    clearStatus();
    m_errorString.clear();
    if (seed.empty()) {
        LOG_ERROR("Electrum seed is empty");
        setStatusError(tr("Electrum seed is empty"));
        return false;
    }
 
    m_recoveringFromSeed = true;
    m_recoveringFromDevice = false;
    crypto::secret_key recovery_key;
    std::string old_language;
    if (!crypto::ElectrumWords::words_to_bytes(seed, recovery_key, old_language)) {
        setStatusError(tr("Electrum-style word list failed verification"));
        return false;
    }
 
    if (old_language == crypto::ElectrumWords::old_language_name)
        old_language = Language::English().get_language_name();
 
    try {
        m_wallet->set_seed_language(old_language);
        m_wallet->generate(path, password, recovery_key, true, false);
 
    } catch (const std::exception &e) {
        setStatusCritical(e.what());
    }
    return status() == Status_Ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recover() [2/2]

bool Electroneum::WalletImpl::recover	(	const std::string &	path,
		const std::string &	seed )

Definition at line 725 of file wallet.cpp.

{
    return recover(path, "", seed);
}

Here is the call graph for this function:

recoverFromDevice()

bool Electroneum::WalletImpl::recoverFromDevice	(	const std::string &	path,
		const std::string &	password,
		const std::string &	device_name )

Definition at line 677 of file wallet.cpp.

{
    clearStatus();
    m_recoveringFromSeed = false;
    m_recoveringFromDevice = true;
    try
    {
        m_wallet->restore(path, password, device_name);
        LOG_PRINT_L1("Generated new wallet from device: " + device_name);
    }
    catch (const std::exception& e) {
        setStatusError(string(tr("failed to generate new wallet: ")) + e.what());
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recoverFromKeys()

bool Electroneum::WalletImpl::recoverFromKeys	(	const std::string &	path,
		const std::string &	language,
		const std::string &	address_string,
		const std::string &	viewkey_string,
		const std::string &	spendkey_string = "" )

Definition at line 572 of file wallet.cpp.

{
    return recoverFromKeysWithPassword(path, "", language, address_string, viewkey_string, spendkey_string);
}

Here is the call graph for this function:

recoverFromKeysWithPassword()

bool Electroneum::WalletImpl::recoverFromKeysWithPassword	(	const std::string &	path,
		const std::string &	password,
		const std::string &	language,
		const std::string &	address_string,
		const std::string &	viewkey_string,
		const std::string &	spendkey_string = "" )

Definition at line 581 of file wallet.cpp.

{
    cryptonote::address_parse_info info;
    if(!get_account_address_from_str(info, m_wallet->nettype(), address_string))
    {
        setStatusError(tr("failed to parse address"));
        return false;
    }
 
    // parse optional spend key
    crypto::secret_key spendkey;
    bool has_spendkey = false;
    if (!spendkey_string.empty()) {
        cryptonote::blobdata spendkey_data;
        if(!epee::string_tools::parse_hexstr_to_binbuff(spendkey_string, spendkey_data) || spendkey_data.size() != sizeof(crypto::secret_key))
        {
            setStatusError(tr("failed to parse secret spend key"));
            return false;
        }
        has_spendkey = true;
        spendkey = *reinterpret_cast<const crypto::secret_key*>(spendkey_data.data());
    }
 
    // parse view secret key
    bool has_viewkey = true;
    crypto::secret_key viewkey;
    if (viewkey_string.empty()) {
        if(has_spendkey) {
          has_viewkey = false;
        }
        else {
          setStatusError(tr("Neither view key nor spend key supplied, cancelled"));
          return false;
        }
    }
    if(has_viewkey) {
      cryptonote::blobdata viewkey_data;
      if(!epee::string_tools::parse_hexstr_to_binbuff(viewkey_string, viewkey_data) || viewkey_data.size() != sizeof(crypto::secret_key))
      {
          setStatusError(tr("failed to parse secret view key"));
          return false;
      }
      viewkey = *reinterpret_cast<const crypto::secret_key*>(viewkey_data.data());
    }
    // check the spend and view keys match the given address
    crypto::public_key pkey;
    if(has_spendkey) {
        if (!crypto::secret_key_to_public_key(spendkey, pkey)) {
            setStatusError(tr("failed to verify secret spend key"));
            return false;
        }
        if (info.address.m_spend_public_key != pkey) {
            setStatusError(tr("spend key does not match address"));
            return false;
        }
    }
    if(has_viewkey) {
       if (!crypto::secret_key_to_public_key(viewkey, pkey)) {
           setStatusError(tr("failed to verify secret view key"));
           return false;
       }
       if (info.address.m_view_public_key != pkey) {
           setStatusError(tr("view key does not match address"));
           return false;
       }
    }
 
    try
    {
        if (has_spendkey && has_viewkey) {
            m_wallet->generate(path, password, info.address, spendkey, viewkey);
            LOG_PRINT_L1("Generated new wallet from spend key and view key");
        }
        if(!has_spendkey && has_viewkey) {
            m_wallet->generate(path, password, info.address, viewkey);
            LOG_PRINT_L1("Generated new view only wallet from keys");
        }
        if(has_spendkey && !has_viewkey) {
           m_wallet->generate(path, password, spendkey, true, false);
           setSeedLanguage(language);
           LOG_PRINT_L1("Generated deterministic wallet from spend key with seed language: " + language);
        }
        
    }
    catch (const std::exception& e) {
        setStatusError(string(tr("failed to generate new wallet: ")) + e.what());
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

refresh()

bool Electroneum::WalletImpl::refresh ( )

overridevirtual

refresh - refreshes the wallet, updating transactions from daemon

Returns

- true if refreshed successfully;

Implements Electroneum::Wallet.

Definition at line 1077 of file wallet.cpp.

{
    clearStatus();
    //TODO: make doRefresh return bool to know whether the error occured during refresh or not
    //otherwise one may try, say, to send transaction, transfer fails and this method returns false
    doRefresh();
    return status() == Status_Ok;
}

Here is the call graph for this function:

refreshAsync()

void Electroneum::WalletImpl::refreshAsync ( )

overridevirtual

refreshAsync - refreshes wallet asynchronously.

Implements Electroneum::Wallet.

Definition at line 1086 of file wallet.cpp.

{
    LOG_PRINT_L3(__FUNCTION__ << ": Refreshing asynchronously..");
    clearStatus();
    m_refreshCV.notify_one();
}

Here is the caller graph for this function:

rescanBlockchain()

bool Electroneum::WalletImpl::rescanBlockchain ( )

overridevirtual

rescanBlockchain - rescans the wallet, updating transactions from daemon

Returns

- true if refreshed successfully;

Implements Electroneum::Wallet.

Definition at line 1093 of file wallet.cpp.

{
    clearStatus();
    m_refreshShouldRescan = true;
    doRefresh();
    return status() == Status_Ok;
}

Here is the call graph for this function:

rescanBlockchainAsync()

void Electroneum::WalletImpl::rescanBlockchainAsync ( )

overridevirtual

rescanBlockchainAsync - rescans wallet asynchronously, starting from genesys

Implements Electroneum::Wallet.

Definition at line 1101 of file wallet.cpp.

{
    m_refreshShouldRescan = true;
    refreshAsync();
}

Here is the call graph for this function:

rescanSpent()

bool Electroneum::WalletImpl::rescanSpent ( )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 2232 of file wallet.cpp.

{
  clearStatus();
  if (!trustedDaemon()) {
    setStatusError(tr("Rescan spent can only be used with a trusted daemon"));
    return false;
  }
  try {
      m_wallet->rescan_spent();
  } catch (const std::exception &e) {
      LOG_ERROR(__FUNCTION__ << " error: " << e.what());
      setStatusError(e.what());
      return false;
  }
  return true;
}

Here is the call graph for this function:

restoreMultisigTransaction()

PendingTransaction * Electroneum::WalletImpl::restoreMultisigTransaction ( const std::string & signData )

overridevirtual

restoreMultisigTransaction creates PendingTransaction from signData

Parameters

signData

encrypted unsigned transaction. Obtained with PendingTransaction::multisigSignData

Returns

PendingTransaction

Implements Electroneum::Wallet.

Definition at line 1374 of file wallet.cpp.

                                                                                 {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);
 
        string binary;
        if (!epee::string_tools::parse_hexstr_to_binbuff(signData, binary)) {
            throw runtime_error("Failed to deserialize multisig transaction");
        }
 
        tools::wallet2::multisig_tx_set txSet;
        if (!m_wallet->load_multisig_tx(binary, txSet, {})) {
          throw runtime_error("couldn't parse multisig transaction data");
        }
 
        auto ptx = new PendingTransactionImpl(*this);
        ptx->m_pending_tx = txSet.m_ptx;
        ptx->m_signers = txSet.m_signers;
 
        return ptx;
    } catch (exception& e) {
        LOG_ERROR("Error on restoring multisig transaction: " << e.what());
        setStatusError(string(tr("Failed to restore multisig transaction: ")) + e.what());
    }
 
    return nullptr;
}

Here is the call graph for this function:

secretSpendKey()

std::string Electroneum::WalletImpl::secretSpendKey ( ) const

overridevirtual

secretSpendKey - returns secret spend key

Returns

- secret spend key

Implements Electroneum::Wallet.

Definition at line 884 of file wallet.cpp.

{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_spend_secret_key);
}

Here is the call graph for this function:

secretViewKey()

std::string Electroneum::WalletImpl::secretViewKey ( ) const

overridevirtual

secretViewKey - returns secret view key

Returns

- secret view key

Implements Electroneum::Wallet.

Definition at line 874 of file wallet.cpp.

{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_view_secret_key);
}

Here is the call graph for this function:

seed()

std::string Electroneum::WalletImpl::seed ( ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 790 of file wallet.cpp.

{
    epee::wipeable_string seed;
    if (m_wallet)
        m_wallet->get_seed(seed);
    return std::string(seed.data(), seed.size()); // TODO
}

Here is the call graph for this function:

Here is the caller graph for this function:

segregatePreForkOutputs()

void Electroneum::WalletImpl::segregatePreForkOutputs ( bool segregate )

overridevirtual

sets whether pre-fork outs are to be segregated

Implements Electroneum::Wallet.

Definition at line 2398 of file wallet.cpp.

{
    m_wallet->segregate_pre_fork_outputs(segregate);
}

segregationHeight()

void Electroneum::WalletImpl::segregationHeight ( uint64_t height )

overridevirtual

sets the height where segregation should occur

Implements Electroneum::Wallet.

Definition at line 2403 of file wallet.cpp.

{
    m_wallet->segregation_height(height);
}

setAutoRefreshInterval()

void Electroneum::WalletImpl::setAutoRefreshInterval ( int millis )

overridevirtual

setAutoRefreshInterval - setup interval for automatic refresh.

Parameters

seconds

- interval in millis. if zero or less than zero - automatic refresh disabled;

Implements Electroneum::Wallet.

Definition at line 1107 of file wallet.cpp.

{
    if (millis > MAX_REFRESH_INTERVAL_MILLIS) {
        LOG_ERROR(__FUNCTION__<< ": invalid refresh interval " << millis
                  << " ms, maximum allowed is " << MAX_REFRESH_INTERVAL_MILLIS << " ms");
        m_refreshIntervalMillis = MAX_REFRESH_INTERVAL_MILLIS;
    } else {
        m_refreshIntervalMillis = millis;
    }
}

setDefaultMixin()

void Electroneum::WalletImpl::setDefaultMixin ( uint32_t arg )

overridevirtual

setDefaultMixin - setum number of mixins to be used for new transactions

Parameters

arg

Implements Electroneum::Wallet.

Definition at line 1705 of file wallet.cpp.

{
    m_wallet->default_mixin(arg);
}

setDevicePassphrase()

bool Electroneum::WalletImpl::setDevicePassphrase ( const std::string & password )

overridevirtual

Reimplemented from Electroneum::Wallet.

Definition at line 849 of file wallet.cpp.

{
    clearStatus();
    try {
        m_wallet->get_account().get_device().set_passphrase(epee::wipeable_string(passphrase.data(), passphrase.size()));
    } catch (const std::exception &e) {
        setStatusError(e.what());
    }
    return status() == Status_Ok;
}

Here is the call graph for this function:

setDevicePin()

bool Electroneum::WalletImpl::setDevicePin ( const std::string & password )

overridevirtual

Reimplemented from Electroneum::Wallet.

Definition at line 838 of file wallet.cpp.

{
    clearStatus();
    try {
        m_wallet->get_account().get_device().set_pin(epee::wipeable_string(pin.data(), pin.size()));
    } catch (const std::exception &e) {
        setStatusError(e.what());
    }
    return status() == Status_Ok;
}

Here is the call graph for this function:

setListener()

void Electroneum::WalletImpl::setListener ( WalletListener * l )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1694 of file wallet.cpp.

{
    // TODO thread synchronization;
    m_wallet2Callback->setListener(l);
}

Here is the caller graph for this function:

setPassword()

bool Electroneum::WalletImpl::setPassword ( const std::string & password )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 826 of file wallet.cpp.

{
    clearStatus();
    try {
        m_wallet->change_password(m_wallet->get_wallet_file(), m_password, password);
        m_password = password;
    } catch (const std::exception &e) {
        setStatusError(e.what());
    }
    return status() == Status_Ok;
}

Here is the call graph for this function:

setRecoveringFromDevice()

void Electroneum::WalletImpl::setRecoveringFromDevice ( bool recoveringFromDevice )

overridevirtual

setRecoveringFromDevice - set state to recovering from device

Parameters

recoveringFromDevice

- true/false

Implements Electroneum::Wallet.

Definition at line 986 of file wallet.cpp.

{
    m_recoveringFromDevice = recoveringFromDevice;
}

setRecoveringFromSeed()

void Electroneum::WalletImpl::setRecoveringFromSeed ( bool recoveringFromSeed )

overridevirtual

setRecoveringFromSeed - set state recover form seed

Parameters

recoveringFromSeed

- true/false

Implements Electroneum::Wallet.

Definition at line 981 of file wallet.cpp.

{
    m_recoveringFromSeed = recoveringFromSeed;
}

setRefreshFromBlockHeight()

void Electroneum::WalletImpl::setRefreshFromBlockHeight ( uint64_t refresh_from_block_height )

overridevirtual

setRefreshFromBlockHeight - start refresh from block height on recover

Parameters

refresh_from_block_height

- blockchain start height

Implements Electroneum::Wallet.

Definition at line 976 of file wallet.cpp.

{
    m_wallet->set_refresh_from_block_height(refresh_from_block_height);
}

Here is the caller graph for this function:

setRing()

bool Electroneum::WalletImpl::setRing ( const std::string & key_image, const std::vector< uint64_t > & ring, bool relative )

overridevirtual

sets the ring used for a key image

Implements Electroneum::Wallet.

Definition at line 2381 of file wallet.cpp.

{
    crypto::key_image raw_key_image;
    if (!epee::string_tools::hex_to_pod(key_image, raw_key_image))
    {
        setStatusError(tr("Failed to parse key image"));
        return false;
    }
    bool ret = m_wallet->set_ring(raw_key_image, ring, relative);
    if (!ret)
    {
        setStatusError(tr("Failed to set ring"));
        return false;
    }
    return true;
}

Here is the call graph for this function:

setSeedLanguage()

void Electroneum::WalletImpl::setSeedLanguage ( const std::string & arg )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 803 of file wallet.cpp.

{
    m_wallet->set_seed_language(arg);
}

Here is the caller graph for this function:

setSubaddressLabel()

void Electroneum::WalletImpl::setSubaddressLabel ( uint32_t accountIndex, uint32_t addressIndex, const std::string & label )

overridevirtual

setSubaddressLabel - sets the label of the specified subaddress

Parameters

accountIndex	- the major index specifying the subaddress account
addressIndex	- the minor index specifying the subaddress
label	- the new label for the specified subaddress

Implements Electroneum::Wallet.

Definition at line 1235 of file wallet.cpp.

{
    try
    {
        return m_wallet->set_subaddress_label({accountIndex, addressIndex}, label);
    }
    catch (const std::exception &e)
    {
        LOG_ERROR("Error setting subaddress label: " << e.what());
        setStatusError(string(tr("Failed to set subaddress label: ")) + e.what());
    }
}

setSubaddressLookahead()

void Electroneum::WalletImpl::setSubaddressLookahead ( uint32_t major, uint32_t minor )

overridevirtual

setSubaddressLookahead - set size of subaddress lookahead

Parameters

major	- size fot the major index
minor	- size fot the minor index

Implements Electroneum::Wallet.

Definition at line 991 of file wallet.cpp.

{
    m_wallet->set_subaddress_lookahead(major, minor);
}

Here is the caller graph for this function:

setTrustedDaemon()

void Electroneum::WalletImpl::setTrustedDaemon ( bool arg )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 2033 of file wallet.cpp.

{
    m_wallet->set_trusted_daemon(arg);
}

setUserNote()

bool Electroneum::WalletImpl::setUserNote ( const std::string & txid, const std::string & note )

overridevirtual

setUserNote - attach an arbitrary string note to a txid

Parameters

txid	- the transaction id to attach the note to
note	- the note

Returns

true if successful, false otherwise

Implements Electroneum::Wallet.

Definition at line 1710 of file wallet.cpp.

{
    cryptonote::blobdata txid_data;
    if(!epee::string_tools::parse_hexstr_to_binbuff(txid, txid_data) || txid_data.size() != sizeof(crypto::hash))
      return false;
    const crypto::hash htxid = *reinterpret_cast<const crypto::hash*>(txid_data.data());
 
    m_wallet->set_tx_note(htxid, note);
    return true;
}

Here is the call graph for this function:

signMessage()

std::string Electroneum::WalletImpl::signMessage ( const std::string & message )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1950 of file wallet.cpp.

{
  return m_wallet->sign(message);
}

Here is the call graph for this function:

signMultisigParticipant()

std::string Electroneum::WalletImpl::signMultisigParticipant ( const std::string & message ) const

overridevirtual

signMultisigParticipant signs given message with the multisig public signer key

Parameters

message

message to sign

Returns

signature in case of success. Sets status to Error and return empty string in case of error

Implements Electroneum::Wallet.

Definition at line 1965 of file wallet.cpp.

{
    clearStatus();
 
    bool ready = false;
    if (!m_wallet->multisig(&ready) || !ready) {
        m_status = Status_Error;
        m_errorString = tr("The wallet must be in multisig ready state");
        return {};
    }
 
    try {
        return m_wallet->sign_multisig_participant(message);
    } catch (const std::exception& e) {
        m_status = Status_Error;
        m_errorString = e.what();
    }
 
    return {};
}

Here is the call graph for this function:

startRefresh()

void Electroneum::WalletImpl::startRefresh ( )

overridevirtual

StartRefresh - Start/resume refresh thread (refresh every 10 seconds).

Implements Electroneum::Wallet.

Definition at line 2140 of file wallet.cpp.

{
    if (!m_refreshEnabled) {
        LOG_PRINT_L2(__FUNCTION__ << ": refresh started/resumed...");
        m_refreshEnabled = true;
        m_refreshCV.notify_one();
    }
}

Here is the caller graph for this function:

status()

int Electroneum::WalletImpl::status ( ) const

overridevirtual

returns wallet status (Status_Ok | Status_Error)

Implements Electroneum::Wallet.

Definition at line 808 of file wallet.cpp.

{
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    return m_status;
}

Here is the caller graph for this function:

statusWithErrorString()

void Electroneum::WalletImpl::statusWithErrorString ( int & status, std::string & errorString ) const

overridevirtual

returns both error and error string atomically. suggested to use in instead of status() and errorString()

Implements Electroneum::Wallet.

Definition at line 820 of file wallet.cpp.

                                                                                {
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    status = m_status;
    errorString = m_errorString;
}

Here is the call graph for this function:

Here is the caller graph for this function:

store()

bool Electroneum::WalletImpl::store ( const std::string & path )

overridevirtual

store - stores wallet to file.

Parameters

path	- main filename to store wallet to. additionally stores address file and keys file. to store to the same file - just pass empty string;

Returns

Implements Electroneum::Wallet.

Definition at line 909 of file wallet.cpp.

{
    clearStatus();
    try {
        if (path.empty()) {
            m_wallet->store();
        } else {
            m_wallet->store_to(path, m_password);
        }
    } catch (const std::exception &e) {
        LOG_ERROR("Error saving wallet: " << e.what());
        setStatusError(e.what());
        return false;
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

subaddress()

Subaddress * Electroneum::WalletImpl::subaddress ( )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1684 of file wallet.cpp.

{
    return m_subaddress.get();
}

subaddressAccount()

SubaddressAccount * Electroneum::WalletImpl::subaddressAccount ( )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1689 of file wallet.cpp.

{
    return m_subaddressAccount.get();
}

submitTransaction()

bool Electroneum::WalletImpl::submitTransaction ( const std::string & fileName )

overridevirtual

submitTransaction - submits transaction in signed tx file

Returns

- true on success

Implements Electroneum::Wallet.

Definition at line 1140 of file wallet.cpp.

                                                         {
  clearStatus();
  std::unique_ptr<PendingTransactionImpl> transaction(new PendingTransactionImpl(*this));
 
  bool r = m_wallet->load_tx(fileName, transaction->m_pending_tx);
  if (!r) {
    setStatus(Status_Ok, tr("Failed to load transaction from file"));
    return false;
  }
  
  if(!transaction->commit()) {
    setStatusError(transaction->m_errorString);
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

synchronized()

bool Electroneum::WalletImpl::synchronized ( ) const

overridevirtual

synchronized - checks if wallet was ever synchronized

Returns

Implements Electroneum::Wallet.

Definition at line 1072 of file wallet.cpp.

{
    return m_synchronized;
}

trustedDaemon()

bool Electroneum::WalletImpl::trustedDaemon ( ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 2038 of file wallet.cpp.

{
    return m_wallet->is_trusted_daemon();
}

Here is the caller graph for this function:

unblackballOutput()

bool Electroneum::WalletImpl::unblackballOutput ( const std::string & amount, const std::string & offset )

overridevirtual

unblackballs an output

Implements Electroneum::Wallet.

Definition at line 2320 of file wallet.cpp.

{
    uint64_t raw_amount, raw_offset;
    if (!epee::string_tools::get_xtype_from_string(raw_amount, amount))
    {
        setStatusError(tr("Failed to parse output amount"));
        return false;
    }
    if (!epee::string_tools::get_xtype_from_string(raw_offset, offset))
    {
        setStatusError(tr("Failed to parse output offset"));
        return false;
    }
    bool ret = m_wallet->unblackball_output(std::make_pair(raw_amount, raw_offset));
    if (!ret)
    {
        setStatusError(tr("Failed to mark output as unspent"));
        return false;
    }
    return true;
}

Here is the call graph for this function:

unlockedBalance()

uint64_t Electroneum::WalletImpl::unlockedBalance ( uint32_t accountIndex = 0, bool public_blockchain = false ) const

overridevirtual

Implements Electroneum::Wallet.

Definition at line 1001 of file wallet.cpp.

{
    return m_wallet->unlocked_balance(accountIndex, public_blockchain);
}

unlockKeysFile()

bool Electroneum::WalletImpl::unlockKeysFile ( )

overridevirtual

Implements Electroneum::Wallet.

Definition at line 2418 of file wallet.cpp.

{
    return m_wallet->unlock_keys_file();
}

useForkRules()

bool Electroneum::WalletImpl::useForkRules ( uint8_t version, int64_t early_blocks ) const

overridevirtual

check if hard fork rules should be used

Implements Electroneum::Wallet.

Definition at line 2255 of file wallet.cpp.

{
    return m_wallet->use_fork_rules(version,early_blocks);
}

verifyMessageWithPublicKey()

bool Electroneum::WalletImpl::verifyMessageWithPublicKey ( const std::string & message, const std::string & publicKey, const std::string & signature ) const

overridevirtual

verifyMessageWithPublicKey verifies that message was signed with the given public key

Parameters

message	message
publicKey	hex encoded public key
signature	signature of the message

Returns

true if the signature is correct. false and sets error state in case of error

Implements Electroneum::Wallet.

Definition at line 1986 of file wallet.cpp.

{
    clearStatus();
 
    cryptonote::blobdata pkeyData;
    if(!epee::string_tools::parse_hexstr_to_binbuff(publicKey, pkeyData) || pkeyData.size() != sizeof(crypto::public_key))
    {
        m_status = Status_Error;
        m_errorString = tr("Given string is not a key");
        return false;
    }
 
    try {
        crypto::public_key pkey = *reinterpret_cast<const crypto::public_key*>(pkeyData.data());
        return m_wallet->verify_with_public_key(message, pkey, signature);
    } catch (const std::exception& e) {
        m_status = Status_Error;
        m_errorString = e.what();
    }
 
    return false;
}

Here is the call graph for this function:

verifySignedMessage()

bool Electroneum::WalletImpl::verifySignedMessage ( const std::string & message, const std::string & addres, const std::string & signature ) const

overridevirtual

verifySignedMessage - verify a signature matches a given message

Parameters

message	- the message (arbitrary byte data)
address	- the address the signature claims to be made with
signature	- the signature

Returns

true if the signature verified, false otherwise

Implements Electroneum::Wallet.

Definition at line 1955 of file wallet.cpp.

{
  cryptonote::address_parse_info info;
 
  if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address))
    return false;
 
  return m_wallet->verify(message, info.address, signature);
}

Here is the call graph for this function:

watchOnly()

bool Electroneum::WalletImpl::watchOnly ( ) const

overridevirtual

watchOnly - checks if wallet is watch only

Returns

- true if watch only

Implements Electroneum::Wallet.

Definition at line 2043 of file wallet.cpp.

{
    return m_wallet->watch_only();
}

Friends And Related Symbol Documentation

AddressBookImpl

friend class AddressBookImpl

friend

Definition at line 224 of file wallet.h.

PendingTransactionImpl

friend class PendingTransactionImpl

friend

Definition at line 220 of file wallet.h.

SubaddressAccountImpl

friend class SubaddressAccountImpl

friend

Definition at line 226 of file wallet.h.

SubaddressImpl

friend class SubaddressImpl

friend

Definition at line 225 of file wallet.h.

TransactionHistoryImpl

friend class TransactionHistoryImpl

friend

Definition at line 222 of file wallet.h.

UnsignedTransactionImpl

friend class UnsignedTransactionImpl

friend

Definition at line 221 of file wallet.h.

Wallet2CallbackImpl

friend struct Wallet2CallbackImpl

friend

Definition at line 223 of file wallet.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/api/wallet.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/wallet/api/wallet.cpp