#include <wallet_manager.hpp>

Public Member Functions
	wallet_manager ()

	wallet_manager (const wallet_manager &)=delete

	wallet_manager (wallet_manager &&)=delete

wallet_manager &	operator= (const wallet_manager &)=delete

wallet_manager &	operator= (wallet_manager &&)=delete

	~wallet_manager ()

void	set_dir (const boost::filesystem::path &p)

void	set_timeout (const std::chrono::seconds &t)

void	set_timeout (int64_t secs)

chain::signed_transaction	sign_transaction (const chain::signed_transaction &txn, const flat_set< public_key_type > &keys, const chain::chain_id_type &id)

chain::signature_type	sign_digest (const chain::digest_type &digest, const public_key_type &key)

std::string	create (const std::string &name)

void	open (const std::string &name)

std::vector< std::string >	list_wallets ()

map< public_key_type, private_key_type >	list_keys (const string &name, const string &pw)

flat_set< public_key_type >	get_public_keys ()

void	lock_all ()
	Locks all the unlocked wallets.

void	lock (const std::string &name)

void	unlock (const std::string &name, const std::string &password)

void	import_key (const std::string &name, const std::string &wif_key)

void	remove_key (const std::string &name, const std::string &password, const std::string &key)

string	create_key (const std::string &name, const std::string &key_type)

void	own_and_use_wallet (const string &name, std::unique_ptr< wallet_api > &&wallet)
	Takes ownership of a wallet to use.

Detailed Description

Provides associate of wallet name to wallet and manages the interaction with each wallet.

The name of the wallet is also used as part of the file name by soft_wallet. See wallet_manager::create. No const methods because timeout may cause lock_all() to be called.

Definition at line 18 of file wallet_manager.hpp.

Constructor & Destructor Documentation

◆ wallet_manager() [1/3]

sysio::wallet::wallet_manager::wallet_manager ( )

Definition at line 25 of file wallet_manager.cpp.

                               {
#ifdef __APPLE__
   try {
      wallets.emplace("SecureEnclave", std::make_unique<se_wallet>());
   } catch(const std::exception& ) {}
#endif
}

◆ wallet_manager() [2/3]

sysio::wallet::wallet_manager::wallet_manager ( const wallet_manager & )

delete

◆ wallet_manager() [3/3]

sysio::wallet::wallet_manager::wallet_manager ( wallet_manager && )

delete

◆ ~wallet_manager()

sysio::wallet::wallet_manager::~wallet_manager ( )

Definition at line 33 of file wallet_manager.cpp.

                                {
   //not really required, but may spook users
   if(wallet_dir_lock)
      boost::filesystem::remove(lock_path);
}

Member Function Documentation

◆ create()

std::string sysio::wallet::wallet_manager::create ( const std::string & name )

Create a new wallet. A new wallet is created in file dir/{name}.wallet see set_dir. The new wallet is unlocked after creation.

Parameters

name	of the wallet and name of the file without ext .wallet.

Returns: Plaintext password that is needed to unlock wallet. Caller is responsible for saving password otherwise they will not be able to unlock their wallet. Note user supplied passwords are not supported.

Exceptions

fc::exception if wallet with name already exists (or filename already exists)

Definition at line 57 of file wallet_manager.cpp.

                                                      {
   check_timeout();
 
   SYS_ASSERT(valid_filename(name), wallet_exception, "Invalid filename, path not allowed in wallet name ${n}", ("n", name));
 
   auto wallet_filename = dir / (name + file_ext);
 
   if (fc::exists(wallet_filename)) {
      SYS_THROW(chain::wallet_exist_exception, "Wallet with name: '${n}' already exists at ${path}", ("n", name)("path",fc::path(wallet_filename)));
   }
 
   std::string password = gen_password();
   wallet_data d;
   auto wallet = make_unique<soft_wallet>(d);
   wallet->set_password(password);
   wallet->set_wallet_filename(wallet_filename.string());
   wallet->unlock(password);
   wallet->lock();
   wallet->unlock(password);
 
   // Explicitly save the wallet file here, to ensure it now exists.
   wallet->save_wallet_file();
 
   // If we have name in our map then remove it since we want the emplace below to replace.
   // This can happen if the wallet file is removed while eos-walletd is running.
   auto it = wallets.find(name);
   if (it != wallets.end()) {
      wallets.erase(it);
   }
   wallets.emplace(name, std::move(wallet));
 
   return password;
}

Here is the call graph for this function:

◆ create_key()

string sysio::wallet::wallet_manager::create_key	(	const std::string &	name,
		const std::string &	key_type )

Creates a key within the specified wallet. Wallet must be opened and unlocked

Parameters

name	of the wallet to create key in
type	of key to create

Exceptions

fc::exception if wallet not found or locked, or if the wallet cannot create said type of key

Returns: The public key of the created key

Definition at line 213 of file wallet_manager.cpp.

                                                                                  {
   check_timeout();
   if (wallets.count(name) == 0) {
      SYS_THROW(chain::wallet_nonexistent_exception, "Wallet not found: ${w}", ("w", name));
   }
   auto& w = wallets.at(name);
   if (w->is_locked()) {
      SYS_THROW(chain::wallet_locked_exception, "Wallet is locked: ${w}", ("w", name));
   }
 
   string upper_key_type = boost::to_upper_copy<std::string>(key_type);
   return w->create_key(upper_key_type);
}

◆ get_public_keys()

flat_set< public_key_type > sysio::wallet::wallet_manager::get_public_keys ( )

Returns: A set of public keys from all unlocked wallets, use with chain_controller::get_required_keys.

Definition at line 138 of file wallet_manager.cpp.

                                                          {
   check_timeout();
   SYS_ASSERT(!wallets.empty(), wallet_not_available_exception, "You don't have any wallet!");
   flat_set<public_key_type> result;
   bool is_all_wallet_locked = true;
   for (const auto& i : wallets) {
      if (!i.second->is_locked()) {
         result.merge(i.second->list_public_keys());
      }
      is_all_wallet_locked &= i.second->is_locked();
   }
   SYS_ASSERT(!is_all_wallet_locked, wallet_locked_exception, "You don't have any unlocked wallet!");
   return result;
}

◆ import_key()

void sysio::wallet::wallet_manager::import_key	(	const std::string &	name,
		const std::string &	wif_key )

Import private key into specified wallet. Imports a WIF Private Key into specified wallet. Wallet must be opened and unlocked.

Parameters

name	the name of the wallet to import into.
wif_key	the WIF Private Key to import, e.g. 5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3

Exceptions

fc::exception if wallet not found or locked.

Definition at line 188 of file wallet_manager.cpp.

                                                                               {
   check_timeout();
   if (wallets.count(name) == 0) {
      SYS_THROW(chain::wallet_nonexistent_exception, "Wallet not found: ${w}", ("w", name));
   }
   auto& w = wallets.at(name);
   if (w->is_locked()) {
      SYS_THROW(chain::wallet_locked_exception, "Wallet is locked: ${w}", ("w", name));
   }
   w->import_key(wif_key);
}

◆ list_keys()

map< public_key_type, private_key_type > sysio::wallet::wallet_manager::list_keys	(	const string &	name,
		const string &	pw )

Returns: A list of private keys from a wallet provided password is correct to said wallet

Definition at line 126 of file wallet_manager.cpp.

                                                                                                    {
   check_timeout();
 
   if (wallets.count(name) == 0)
      SYS_THROW(chain::wallet_nonexistent_exception, "Wallet not found: ${w}", ("w", name));
   auto& w = wallets.at(name);
   if (w->is_locked())
      SYS_THROW(chain::wallet_locked_exception, "Wallet is locked: ${w}", ("w", name));
   w->check_password(pw); //throws if bad password
   return w->list_keys();
}

◆ list_wallets()

std::vector< std::string > sysio::wallet::wallet_manager::list_wallets ( )

Returns: A list of wallet names with " *" appended if the wallet is unlocked.

Definition at line 113 of file wallet_manager.cpp.

                                                  {
   check_timeout();
   std::vector<std::string> result;
   for (const auto& i : wallets) {
      if (i.second->is_locked()) {
         result.emplace_back(i.first);
      } else {
         result.emplace_back(i.first + " *");
      }
   }
   return result;
}

◆ lock()

void sysio::wallet::wallet_manager::lock ( const std::string & name )

Lock the specified wallet. No-op if wallet already locked.

Parameters

name	the name of the wallet to lock.

Exceptions

fc::exception if wallet with name not found.

Definition at line 163 of file wallet_manager.cpp.

                                               {
   check_timeout();
   if (wallets.count(name) == 0) {
      SYS_THROW(chain::wallet_nonexistent_exception, "Wallet not found: ${w}", ("w", name));
   }
   auto& w = wallets.at(name);
   if (w->is_locked()) {
      return;
   }
   w->lock();
}

◆ lock_all()

void sysio::wallet::wallet_manager::lock_all ( )

Definition at line 154 of file wallet_manager.cpp.

                              {
   // no call to check_timeout since we are locking all anyway
   for (auto& i : wallets) {
      if (!i.second->is_locked()) {
         i.second->lock();
      }
   }
}

◆ open()

void sysio::wallet::wallet_manager::open ( const std::string & name )

Open an existing wallet file dir/{name}.wallet. Note this does not unlock the wallet, see wallet_manager::unlock.

Parameters

name	of the wallet file (minus ext .wallet) to open.

Exceptions

fc::exception if unable to find/open the wallet file.

Definition at line 91 of file wallet_manager.cpp.

                                               {
   check_timeout();
 
   SYS_ASSERT(valid_filename(name), wallet_exception, "Invalid filename, path not allowed in wallet name ${n}", ("n", name));
 
   wallet_data d;
   auto wallet = std::make_unique<soft_wallet>(d);
   auto wallet_filename = dir / (name + file_ext);
   wallet->set_wallet_filename(wallet_filename.string());
   if (!wallet->load_wallet_file()) {
      SYS_THROW(chain::wallet_nonexistent_exception, "Unable to open file: ${f}", ("f", wallet_filename.string()));
   }
 
   // If we have name in our map then remove it since we want the emplace below to replace.
   // This can happen if the wallet file is added while eos-walletd is running.
   auto it = wallets.find(name);
   if (it != wallets.end()) {
      wallets.erase(it);
   }
   wallets.emplace(name, std::move(wallet));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

wallet_manager & sysio::wallet::wallet_manager::operator= ( const wallet_manager & )

delete

◆ operator=() [2/2]

wallet_manager & sysio::wallet::wallet_manager::operator= ( wallet_manager && )

delete

◆ own_and_use_wallet()

void sysio::wallet::wallet_manager::own_and_use_wallet	(	const string &	name,
		std::unique_ptr< wallet_api > &&	wallet )

Definition at line 269 of file wallet_manager.cpp.

                                                                                              {
   if(wallets.find(name) != wallets.end())
      SYS_THROW(wallet_exception, "Tried to use wallet name that already exists.");
   wallets.emplace(name, std::move(wallet));
}

◆ remove_key()

void sysio::wallet::wallet_manager::remove_key	(	const std::string &	name,
		const std::string &	password,
		const std::string &	key )

Removes a key from the specified wallet. Wallet must be opened and unlocked.

Parameters

name	the name of the wallet to remove the key from.
password	the plaintext password returned from create.
key	the Public Key to remove, e.g. SYS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV

Exceptions

fc::exception if wallet not found or locked or key is not removed.

Definition at line 200 of file wallet_manager.cpp.

                                                                                                      {
   check_timeout();
   if (wallets.count(name) == 0) {
      SYS_THROW(chain::wallet_nonexistent_exception, "Wallet not found: ${w}", ("w", name));
   }
   auto& w = wallets.at(name);
   if (w->is_locked()) {
      SYS_THROW(chain::wallet_locked_exception, "Wallet is locked: ${w}", ("w", name));
   }
   w->check_password(password); //throws if bad password
   w->remove_key(key);
}

◆ set_dir()

void sysio::wallet::wallet_manager::set_dir ( const boost::filesystem::path & p )

inline

Set the path for location of wallet files.

Parameters

p	path to override default ./ location of wallet files.

Definition at line 29 of file wallet_manager.hpp.

                                              {
      dir = p;
      initialize_lock();
   }

◆ set_timeout() [1/2]

void sysio::wallet::wallet_manager::set_timeout ( const std::chrono::seconds & t )

Set the timeout for locking all wallets. If set then after t seconds of inactivity then lock_all(). Activity is defined as any wallet_manager method call below.

Definition at line 39 of file wallet_manager.cpp.

                                                          {
   timeout = t;
   auto now = std::chrono::system_clock::now();
   timeout_time = now + timeout;
   SYS_ASSERT(timeout_time >= now && timeout_time.time_since_epoch().count() > 0, invalid_lock_timeout_exception, "Overflow on timeout_time, specified ${t}, now ${now}, timeout_time ${timeout_time}",
             ("t", t.count())("now", now.time_since_epoch().count())("timeout_time", timeout_time.time_since_epoch().count()));
}

◆ set_timeout() [2/2]

void sysio::wallet::wallet_manager::set_timeout ( int64_t secs )

inline

See also: wallet_manager::set_timeout(const std::chrono::seconds& t)

Parameters

secs	The timeout in seconds.

Definition at line 41 of file wallet_manager.hpp.

41{ set_timeout(std::chrono::seconds(secs)); }

sysio::wallet::wallet_manager::set_timeout

void set_timeout(const std::chrono::seconds &t)

Definition wallet_manager.cpp:39

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign_digest()

chain::signature_type sysio::wallet::wallet_manager::sign_digest	(	const chain::digest_type &	digest,
		const public_key_type &	key )

Sign digest with the private keys specified via their public keys.

Parameters

digest	the digest to sign.
key	the public key of the corresponding private key to sign the digest with

Returns: signature over the digest

Exceptions

fc::exception if corresponding private keys not found in unlocked wallets

Definition at line 253 of file wallet_manager.cpp.

                                                                                      {
   check_timeout();
 
   try {
      for (const auto& i : wallets) {
         if (!i.second->is_locked()) {
            std::optional<signature_type> sig = i.second->try_sign_digest(digest, key);
            if (sig)
               return *sig;
         }
      }
   } FC_LOG_AND_RETHROW();
 
   SYS_THROW(chain::wallet_missing_pub_key_exception, "Public key not found in unlocked wallets ${k}", ("k", key));
}

Here is the call graph for this function:

◆ sign_transaction()

chain::signed_transaction sysio::wallet::wallet_manager::sign_transaction	(	const chain::signed_transaction &	txn,
		const flat_set< public_key_type > &	keys,
		const chain::chain_id_type &	id )

Sign transaction with the private keys specified via their public keys. Use chain_controller::get_required_keys to determine which keys are needed for txn.

Parameters

txn	the transaction to sign.
keys	the public keys of the corresponding private keys to sign the transaction with
id	the chain_id to sign transaction with.

Returns: txn signed

Exceptions

fc::exception if corresponding private keys not found in unlocked wallets

Definition at line 228 of file wallet_manager.cpp.

                                                                                                                                        {
   check_timeout();
   chain::signed_transaction stxn(txn);
 
   for (const auto& pk : keys) {
      bool found = false;
      for (const auto& i : wallets) {
         if (!i.second->is_locked()) {
            std::optional<signature_type> sig = i.second->try_sign_digest(stxn.sig_digest(id, stxn.context_free_data), pk);
            if (sig) {
               stxn.signatures.push_back(*sig);
               found = true;
               break; // inner for
            }
         }
      }
      if (!found) {
         SYS_THROW(chain::wallet_missing_pub_key_exception, "Public key not found in unlocked wallets ${k}", ("k", pk));
      }
   }
 
   return stxn;
}

Here is the call graph for this function:

◆ unlock()

void sysio::wallet::wallet_manager::unlock	(	const std::string &	name,
		const std::string &	password )

Unlock the specified wallet. The wallet remains unlocked until lock is called or program exit.

Parameters

name	the name of the wallet to lock.
password	the plaintext password returned from create.

Exceptions

fc::exception if wallet not found or invalid password or already unlocked.

Definition at line 175 of file wallet_manager.cpp.

                                                                            {
   check_timeout();
   if (wallets.count(name) == 0) {
      open( name );
   }
   auto& w = wallets.at(name);
   if (!w->is_locked()) {
      SYS_THROW(chain::wallet_unlocked_exception, "Wallet is already unlocked: ${w}", ("w", name));
      return;
   }
   w->unlock(password);
}

Here is the call graph for this function:

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

plugins/wallet_plugin/include/sysio/wallet_plugin/wallet_manager.hpp
plugins/wallet_plugin/wallet_manager.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ wallet_manager() [1/3]

◆ wallet_manager() [2/3]

◆ wallet_manager() [3/3]

◆ ~wallet_manager()

Member Function Documentation

◆ create()

◆ create_key()

◆ get_public_keys()

◆ import_key()

◆ list_keys()

◆ list_wallets()

◆ lock()

◆ lock_all()

◆ open()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ own_and_use_wallet()

◆ remove_key()

◆ set_dir()

◆ set_timeout() [1/2]

◆ set_timeout() [2/2]

◆ sign_digest()

◆ sign_transaction()

◆ unlock()