Electroneum::WalletManagerImpl Class Reference

#include <wallet_manager.h>

Inheritance diagram for Electroneum::WalletManagerImpl:

Collaboration diagram for Electroneum::WalletManagerImpl:

Public Member Functions
Wallet *	createWallet (const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds=1) override
	Creates new wallet.
Wallet *	openWallet (const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds=1, WalletListener *listener=nullptr) override
	Opens existing wallet.
virtual Wallet *	recoveryWallet (const std::string &path, const std::string &password, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight, uint64_t kdf_rounds=1) override
	recovers existing wallet using mnemonic (electrum seed)
virtual Wallet *	createWalletFromKeys (const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t restoreHeight, const std::string &addressString, const std::string &viewKeyString, const std::string &spendKeyString="", uint64_t kdf_rounds=1) override
	recovers existing wallet using keys. Creates a view only wallet if spend key is omitted
virtual Wallet *	recoveryWallet (const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight) override
	recovers existing wallet using mnemonic (electrum seed)
virtual Wallet *	createWalletFromKeys (const std::string &path, const std::string &language, NetworkType nettype, uint64_t restoreHeight, const std::string &addressString, const std::string &viewKeyString, const std::string &spendKeyString="") override
	recovers existing wallet using keys. Creates a view only wallet if spend key is omitted
virtual Wallet *	createWalletFromDevice (const std::string &path, const std::string &password, NetworkType nettype, const std::string &deviceName, uint64_t restoreHeight=0, const std::string &subaddressLookahead="", uint64_t kdf_rounds=1, WalletListener *listener=nullptr) override
	creates wallet using hardware device.
virtual bool	closeWallet (Wallet *wallet, bool store=true) override
	Closes wallet. In case operation succeeded, wallet object deleted. in case operation failed, wallet object not deleted.
bool	walletExists (const std::string &path) override
	TODO: delme walletExists - check if the given filename is the wallet.
bool	verifyWalletPassword (const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds=1) const override
	verifyWalletPassword - check if the given filename is the wallet
bool	queryWalletDevice (Wallet::Device &device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds=1) const override
	determine the key storage for the specified wallet file
std::vector< std::string >	findWallets (const std::string &path) override
	findWallets - searches for the wallet files by given path name recursively
std::string	errorString () const override
	returns verbose error string regarding last error;
void	setDaemonAddress (const std::string &address) override
	set the daemon address (hostname and port)
bool	connected (uint32_t *version=NULL) override
	returns whether the daemon can be reached, and its version number
uint64_t	blockchainHeight () override
	returns current blockchain height
uint64_t	blockchainTargetHeight () override
	returns current blockchain target height
uint64_t	networkDifficulty () override
	returns current network difficulty
double	miningHashRate () override
	returns current mining hash rate (0 if not mining)
uint64_t	blockTarget () override
	returns current block target
bool	isMining () override
	returns true iff mining
bool	startMining (const std::string &address, uint32_t threads=1, bool background_mining=false, bool ignore_battery=true) override
	starts mining with the set number of threads
bool	stopMining () override
	stops mining
std::string	resolveOpenAlias (const std::string &address, bool &dnssec_valid) const override
	resolves an OpenAlias address to a electroneum address
Public Member Functions inherited from Electroneum::WalletManager
Wallet *	createWallet (const std::string &path, const std::string &password, const std::string &language, bool testnet=false)
Wallet *	openWallet (const std::string &path, const std::string &password, bool testnet=false)
Wallet *	recoveryWallet (const std::string &path, const std::string &password, const std::string &mnemonic, bool testnet=false, uint64_t restoreHeight=0)
Wallet *	recoveryWallet (const std::string &path, const std::string &mnemonic, bool testnet=false, uint64_t restoreHeight=0)
Wallet *	createWalletFromKeys (const std::string &path, const std::string &password, const std::string &language, bool testnet, uint64_t restoreHeight, const std::string &addressString, const std::string &viewKeyString, const std::string &spendKeyString="")
Wallet *	createWalletFromKeys (const std::string &path, const std::string &language, bool testnet, uint64_t restoreHeight, const std::string &addressString, const std::string &viewKeyString, const std::string &spendKeyString="")

Friends
struct	WalletManagerFactory

Additional Inherited Members
Static Public Member Functions inherited from Electroneum::WalletManager
static std::tuple< bool, std::string, std::string, std::string, std::string >	checkUpdates (const std::string &software, std::string subdir)
	checks for an update and returns version, hash and url

Detailed Description

Definition at line 39 of file wallet_manager.h.

Member Function Documentation

blockchainHeight()

uint64_t Electroneum::WalletManagerImpl::blockchainHeight ( )

overridevirtual

returns current blockchain height

Implements Electroneum::WalletManager.

Definition at line 252 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_GET_INFO::request ireq;
    cryptonote::COMMAND_RPC_GET_INFO::response ires;
 
    if (!epee::net_utils::invoke_http_json("/getinfo", ireq, ires, m_http_client))
      return 0;
    return ires.height;
}

Here is the call graph for this function:

blockchainTargetHeight()

uint64_t Electroneum::WalletManagerImpl::blockchainTargetHeight ( )

overridevirtual

returns current blockchain target height

Implements Electroneum::WalletManager.

Definition at line 262 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_GET_INFO::request ireq;
    cryptonote::COMMAND_RPC_GET_INFO::response ires;
 
    if (!epee::net_utils::invoke_http_json("/getinfo", ireq, ires, m_http_client))
      return 0;
    return ires.target_height >= ires.height ? ires.target_height : ires.height;
}

Here is the call graph for this function:

blockTarget()

uint64_t Electroneum::WalletManagerImpl::blockTarget ( )

overridevirtual

returns current block target

Implements Electroneum::WalletManager.

Definition at line 295 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_GET_INFO::request ireq;
    cryptonote::COMMAND_RPC_GET_INFO::response ires;
 
    if (!epee::net_utils::invoke_http_json("/getinfo", ireq, ires, m_http_client))
        return 0;
    return ires.target;
}

Here is the call graph for this function:

closeWallet()

bool Electroneum::WalletManagerImpl::closeWallet ( Wallet * wallet, bool store = true )

overridevirtual

Closes wallet. In case operation succeeded, wallet object deleted. in case operation failed, wallet object not deleted.

Parameters

wallet

previously opened / created wallet instance

Returns

None

Implements Electroneum::WalletManager.

Definition at line 154 of file wallet_manager.cpp.

{
    WalletImpl * wallet_ = dynamic_cast<WalletImpl*>(wallet);
    if (!wallet_)
        return false;
    bool result = wallet_->close(store);
    if (!result) {
        m_errorString = wallet_->errorString();
    } else {
        delete wallet_;
    }
    return result;
}

Here is the call graph for this function:

connected()

bool Electroneum::WalletManagerImpl::connected ( uint32_t * version = NULL )

overridevirtual

returns whether the daemon can be reached, and its version number

Implements Electroneum::WalletManager.

Definition at line 237 of file wallet_manager.cpp.

{
    epee::json_rpc::request<cryptonote::COMMAND_RPC_GET_VERSION::request> req_t = AUTO_VAL_INIT(req_t);
    epee::json_rpc::response<cryptonote::COMMAND_RPC_GET_VERSION::response, std::string> resp_t = AUTO_VAL_INIT(resp_t);
    req_t.jsonrpc = "2.0";
    req_t.id = epee::serialization::storage_entry(0);
    req_t.method = "get_version";
    if (!epee::net_utils::invoke_http_json("/json_rpc", req_t, resp_t, m_http_client))
      return false;
 
    if (version)
        *version = resp_t.result.version;
    return true;
}

Here is the call graph for this function:

createWallet()

Wallet * Electroneum::WalletManagerImpl::createWallet ( const std::string & path, const std::string & password, const std::string & language, NetworkType nettype, uint64_t kdf_rounds = 1 )

overridevirtual

Creates new wallet.

Parameters

path	Name of wallet file
password	Password of wallet file
language	Language to be used to generate electrum seed mnemonic
nettype	Network type
kdf_rounds	Number of rounds for key derivation function

Returns

Wallet instance (Wallet::status() needs to be called to check if created successfully)

Implements Electroneum::WalletManager.

Definition at line 53 of file wallet_manager.cpp.

{
    WalletImpl * wallet = new WalletImpl(nettype, kdf_rounds);
    wallet->create(path, password, language);
    return wallet;
}

Here is the call graph for this function:

createWalletFromDevice()

Wallet * Electroneum::WalletManagerImpl::createWalletFromDevice ( const std::string & path, const std::string & password, NetworkType nettype, const std::string & deviceName, uint64_t restoreHeight = 0, const std::string & subaddressLookahead = "", uint64_t kdf_rounds = 1, WalletListener * listener = nullptr )

overridevirtual

creates wallet using hardware device.

Parameters

path	Name of wallet file to be created
password	Password of wallet file
nettype	Network type
deviceName	Device name
restoreHeight	restore from start height (0 sets to current height)
subaddressLookahead	Size of subaddress lookahead (empty sets to some default low value)
kdf_rounds	Number of rounds for key derivation function
listener	Wallet listener to set to the wallet after creation

Returns

Wallet instance (Wallet::status() needs to be called to check if recovered successfully)

Implements Electroneum::WalletManager.

Definition at line 125 of file wallet_manager.cpp.

{
    WalletImpl * wallet = new WalletImpl(nettype, kdf_rounds);
    wallet->setListener(listener);
    if (listener){
        listener->onSetWallet(wallet);
    }
 
    if(restoreHeight > 0){
        wallet->setRefreshFromBlockHeight(restoreHeight);
    } else {
        wallet->setRefreshFromBlockHeight(wallet->estimateBlockChainHeight());
    }
    auto lookahead = tools::parse_subaddress_lookahead(subaddressLookahead);
    if (lookahead)
    {
        wallet->setSubaddressLookahead(lookahead->first, lookahead->second);
    }
    wallet->recoverFromDevice(path, password, deviceName);
    return wallet;
}

Here is the call graph for this function:

createWalletFromKeys() [1/2]

Wallet * Electroneum::WalletManagerImpl::createWalletFromKeys ( const std::string & path, const std::string & language, NetworkType nettype, uint64_t restoreHeight, const std::string & addressString, const std::string & viewKeyString, const std::string & spendKeyString = "" )

overridevirtual

recovers existing wallet using keys. Creates a view only wallet if spend key is omitted

Deprecated

this method creates a wallet WITHOUT a passphrase, use createWalletFromKeys(..., password, ...) instead

Parameters

path	Name of wallet file to be created
language	language
nettype	Network type
restoreHeight	restore from start height
addressString	public address
viewKeyString	view key
spendKeyString	spend key (optional)

Returns

Wallet instance (Wallet::status() needs to be called to check if recovered successfully)

Implements Electroneum::WalletManager.

Definition at line 80 of file wallet_manager.cpp.

{
    return createWalletFromKeys(path, "", language, nettype, restoreHeight,
                                addressString, viewKeyString, spendKeyString);
}

Here is the call graph for this function:

createWalletFromKeys() [2/2]

Wallet * Electroneum::WalletManagerImpl::createWalletFromKeys ( const std::string & path, const std::string & password, const std::string & language, NetworkType nettype, uint64_t restoreHeight, const std::string & addressString, const std::string & viewKeyString, const std::string & spendKeyString = "", uint64_t kdf_rounds = 1 )

overridevirtual

recovers existing wallet using keys. Creates a view only wallet if spend key is omitted

Parameters

path	Name of wallet file to be created
password	Password of wallet file
language	language
nettype	Network type
restoreHeight	restore from start height
addressString	public address
viewKeyString	view key
spendKeyString	spend key (optional)
kdf_rounds	Number of rounds for key derivation function

Returns

Wallet instance (Wallet::status() needs to be called to check if recovered successfully)

Implements Electroneum::WalletManager.

Definition at line 107 of file wallet_manager.cpp.

{
    WalletImpl * wallet = new WalletImpl(nettype, kdf_rounds);
    if(restoreHeight > 0){
        wallet->setRefreshFromBlockHeight(restoreHeight);
    }
    wallet->recoverFromKeysWithPassword(path, password, language, addressString, viewKeyString, spendKeyString);
    return wallet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

errorString()

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

overridevirtual

returns verbose error string regarding last error;

Implements Electroneum::WalletManager.

Definition at line 224 of file wallet_manager.cpp.

{
    return m_errorString;
}

findWallets()

std::vector< std::string > Electroneum::WalletManagerImpl::findWallets ( const std::string & path )

overridevirtual

findWallets - searches for the wallet files by given path name recursively

Parameters

path	- starting point to search

Returns

- list of strings with found wallets (absolute paths);

Implements Electroneum::WalletManager.

Definition at line 192 of file wallet_manager.cpp.

{
    std::vector<std::string> result;
    boost::filesystem::path work_dir(path);
    // return empty result if path doesn't exist
    if(!boost::filesystem::is_directory(path)){
        return result;
    }
    const boost::regex wallet_rx("(.*)\\.(keys)$"); // searching for <wallet_name>.keys files
    boost::filesystem::recursive_directory_iterator end_itr; // Default ctor yields past-the-end
    for (boost::filesystem::recursive_directory_iterator itr(path); itr != end_itr; ++itr) {
        // Skip if not a file
        if (!boost::filesystem::is_regular_file(itr->status()))
            continue;
        boost::smatch what;
        std::string filename = itr->path().filename().string();
 
        LOG_PRINT_L3("Checking filename: " << filename);
 
        bool matched = boost::regex_match(filename, what, wallet_rx);
        if (matched) {
            // if keys file found, checking if there's wallet file itself
            std::string wallet_file = (itr->path().parent_path() /= what[1].str()).string();
            if (boost::filesystem::exists(wallet_file)) {
                LOG_PRINT_L3("Found wallet: " << wallet_file);
                result.push_back(wallet_file);
            }
        }
    }
    return result;
}

isMining()

bool Electroneum::WalletManagerImpl::isMining ( )

overridevirtual

returns true iff mining

Implements Electroneum::WalletManager.

Definition at line 305 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_MINING_STATUS::request mreq;
    cryptonote::COMMAND_RPC_MINING_STATUS::response mres;
 
    if (!epee::net_utils::invoke_http_json("/mining_status", mreq, mres, m_http_client))
      return false;
    return mres.active;
}

Here is the call graph for this function:

miningHashRate()

double Electroneum::WalletManagerImpl::miningHashRate ( )

overridevirtual

returns current mining hash rate (0 if not mining)

Implements Electroneum::WalletManager.

Definition at line 282 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_MINING_STATUS::request mreq;
    cryptonote::COMMAND_RPC_MINING_STATUS::response mres;
 
    epee::net_utils::http::http_simple_client http_client;
    if (!epee::net_utils::invoke_http_json("/mining_status", mreq, mres, m_http_client))
      return 0.0;
    if (!mres.active)
      return 0.0;
    return mres.speed;
}

Here is the call graph for this function:

networkDifficulty()

uint64_t Electroneum::WalletManagerImpl::networkDifficulty ( )

overridevirtual

returns current network difficulty

Implements Electroneum::WalletManager.

Definition at line 272 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_GET_INFO::request ireq;
    cryptonote::COMMAND_RPC_GET_INFO::response ires;
 
    if (!epee::net_utils::invoke_http_json("/getinfo", ireq, ires, m_http_client))
      return 0;
    return ires.difficulty;
}

Here is the call graph for this function:

openWallet()

Wallet * Electroneum::WalletManagerImpl::openWallet ( const std::string & path, const std::string & password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr )

overridevirtual

Opens existing wallet.

Parameters

path	Name of wallet file
password	Password of wallet file
nettype	Network type
kdf_rounds	Number of rounds for key derivation function
listener	Wallet listener to set to the wallet after creation

Returns

Wallet instance (Wallet::status() needs to be called to check if opened successfully)

Implements Electroneum::WalletManager.

Definition at line 61 of file wallet_manager.cpp.

{
    WalletImpl * wallet = new WalletImpl(nettype, kdf_rounds);
    wallet->setListener(listener);
    if (listener){
        listener->onSetWallet(wallet);
    }
 
    wallet->open(path, password);
    //Refresh addressBook
    wallet->addressBook()->refresh(); 
    return wallet;
}

Here is the call graph for this function:

queryWalletDevice()

bool Electroneum::WalletManagerImpl::queryWalletDevice ( Wallet::Device & device_type, const std::string & keys_file_name, const std::string & password, uint64_t kdf_rounds = 1 ) const

overridevirtual

determine the key storage for the specified wallet file

Parameters

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

Returns

true if password correct, else false

for verification only - determines key storage hardware

Implements Electroneum::WalletManager.

Definition at line 184 of file wallet_manager.cpp.

{
    hw::device::device_type type;
    bool r = tools::wallet2::query_device(type, keys_file_name, password, kdf_rounds);
    device_type = static_cast<Wallet::Device>(type);
    return r;
}

Here is the call graph for this function:

recoveryWallet() [1/2]

Wallet * Electroneum::WalletManagerImpl::recoveryWallet ( const std::string & path, const std::string & mnemonic, NetworkType nettype, uint64_t restoreHeight )

overridevirtual

recovers existing wallet using mnemonic (electrum seed)

Deprecated

this method creates a wallet WITHOUT a passphrase, use the alternate recoverWallet() method

Parameters

path	Name of wallet file to be created
mnemonic	mnemonic (25 words electrum seed)
nettype	Network type
restoreHeight	restore from start height

Returns

Wallet instance (Wallet::status() needs to be called to check if recovered successfully)

Implements Electroneum::WalletManager.

Definition at line 75 of file wallet_manager.cpp.

{
    return recoveryWallet(path, "", mnemonic, nettype, restoreHeight);
}

Here is the call graph for this function:

recoveryWallet() [2/2]

Wallet * Electroneum::WalletManagerImpl::recoveryWallet ( const std::string & path, const std::string & password, const std::string & mnemonic, NetworkType nettype, uint64_t restoreHeight, uint64_t kdf_rounds = 1 )

overridevirtual

recovers existing wallet using mnemonic (electrum seed)

Parameters

path	Name of wallet file to be created
password	Password of wallet file
mnemonic	mnemonic (25 words electrum seed)
nettype	Network type
restoreHeight	restore from start height
kdf_rounds	Number of rounds for key derivation function

Returns

Wallet instance (Wallet::status() needs to be called to check if recovered successfully)

Implements Electroneum::WalletManager.

Definition at line 92 of file wallet_manager.cpp.

{
    WalletImpl * wallet = new WalletImpl(nettype, kdf_rounds);
    if(restoreHeight > 0){
        wallet->setRefreshFromBlockHeight(restoreHeight);
    }
    wallet->recover(path, password, mnemonic);
    return wallet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resolveOpenAlias()

std::string Electroneum::WalletManagerImpl::resolveOpenAlias ( const std::string & address, bool & dnssec_valid ) const

overridevirtual

resolves an OpenAlias address to a electroneum address

Implements Electroneum::WalletManager.

Definition at line 340 of file wallet_manager.cpp.

{
    std::vector<std::string> addresses = tools::dns_utils::addresses_from_url(address, dnssec_valid);
    if (addresses.empty())
        return "";
    return addresses.front();
}

Here is the call graph for this function:

setDaemonAddress()

void Electroneum::WalletManagerImpl::setDaemonAddress ( const std::string & address )

overridevirtual

set the daemon address (hostname and port)

Implements Electroneum::WalletManager.

Definition at line 229 of file wallet_manager.cpp.

{
    m_daemonAddress = address;
    if(m_http_client.is_connected())
        m_http_client.disconnect();
    m_http_client.set_server(address, boost::none);
}

startMining()

bool Electroneum::WalletManagerImpl::startMining ( const std::string & address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true )

overridevirtual

starts mining with the set number of threads

Implements Electroneum::WalletManager.

Definition at line 315 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_START_MINING::request mreq;
    cryptonote::COMMAND_RPC_START_MINING::response mres;
 
    mreq.miner_address = address;
    mreq.threads_count = threads;
    mreq.ignore_battery = ignore_battery;
    mreq.do_background_mining = background_mining;
 
    if (!epee::net_utils::invoke_http_json("/start_mining", mreq, mres, m_http_client))
      return false;
    return mres.status == CORE_RPC_STATUS_OK;
}

Here is the call graph for this function:

stopMining()

bool Electroneum::WalletManagerImpl::stopMining ( )

overridevirtual

stops mining

Implements Electroneum::WalletManager.

Definition at line 330 of file wallet_manager.cpp.

{
    cryptonote::COMMAND_RPC_STOP_MINING::request mreq;
    cryptonote::COMMAND_RPC_STOP_MINING::response mres;
 
    if (!epee::net_utils::invoke_http_json("/stop_mining", mreq, mres, m_http_client))
      return false;
    return mres.status == CORE_RPC_STATUS_OK;
}

Here is the call graph for this function:

verifyWalletPassword()

bool Electroneum::WalletManagerImpl::verifyWalletPassword ( const std::string & keys_file_name, const std::string & password, bool no_spend_key, uint64_t kdf_rounds = 1 ) const

overridevirtual

verifyWalletPassword - check if the given filename is the wallet

Parameters

keys_file_name	- location of keys file
password	- password to verify
no_spend_key	- verify only view keys?
kdf_rounds	- number of rounds for key derivation function

Returns

- true if password is correct

Note

This function will fail when the wallet keys file is opened because the wallet program locks the keys file. In this case, Wallet::unlockKeysFile() and Wallet::lockKeysFile() need to be called before and after the call to this function, respectively.

Implements Electroneum::WalletManager.

Definition at line 179 of file wallet_manager.cpp.

{
        return tools::wallet2::verify_password(keys_file_name, password, no_spend_key, hw::get_device("default"), kdf_rounds);
}

Here is the call graph for this function:

walletExists()

bool Electroneum::WalletManagerImpl::walletExists ( const std::string & path )

overridevirtual

TODO: delme walletExists - check if the given filename is the wallet.

Parameters

path	- filename

Returns

- true if wallet exists

Implements Electroneum::WalletManager.

Definition at line 168 of file wallet_manager.cpp.

{
    bool keys_file_exists;
    bool wallet_file_exists;
    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
    if(keys_file_exists){
        return true;
    }
    return false;
}

Here is the call graph for this function:

Friends And Related Symbol Documentation

WalletManagerFactory

friend struct WalletManagerFactory

friend

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