wallet_manager.hpp

Go to the documentation of this file.

#pragma once
#include <sysio/chain/transaction.hpp>
#include <sysio/wallet_plugin/wallet_api.hpp>
#include <boost/asio/deadline_timer.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/interprocess/sync/file_lock.hpp>
#include <chrono>
 
namespace fc { class variant; }
 
namespace sysio {
namespace wallet {
 
class wallet_manager {
public:
   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) {
      dir = p;
      initialize_lock();
   }
 
   void set_timeout(const std::chrono::seconds& t);
 
   void set_timeout(int64_t secs) { set_timeout(std::chrono::seconds(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();
 
   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);
 
private:
   void check_timeout();
 
private:
   using timepoint_t = std::chrono::time_point<std::chrono::system_clock>;
   std::map<std::string, std::unique_ptr<wallet_api>> wallets;
   std::chrono::seconds timeout = std::chrono::seconds::max(); 
   mutable timepoint_t timeout_time = timepoint_t::max(); 
   boost::filesystem::path dir = ".";
   boost::filesystem::path lock_path = dir / "wallet.lock";
   std::unique_ptr<boost::interprocess::file_lock> wallet_dir_lock;
 
   void start_lock_watch(std::shared_ptr<boost::asio::deadline_timer> t);
   void initialize_lock();
};
 
} // namespace wallet
} // namespace sysio