remove keydata_singleton

Author: sinev-valentine

keychain_cmd_app/cmd_parser.cpp

@@ -115,39 +115,12 @@ int cmd_parser::run(int argc, const char* const argv[])
   sec_mod->connect(keychain_ref);
   gui_mod->connect(keychain_ref);
 
+
   auto& keyfiles = keyfile_singleton::instance();
   auto it = keyfiles.begin();
   if ( it==keyfiles.end() )
-  {
-      auto res = keychain_ref.entropy();
-      auto& key_data = keydata_singleton::instance();
-      dev::bytes ue;
-
-      std::string pass("blank");
-//      std::string level("{\"root\": \"m\",\"purpose\": 0, \"coin_type\": 0, \"account\": 0, \"change\": 0, \"address_index\": 0}");
-      keydata::path_levels_t path;
-      path.root="m";
-      path.purpose=0;
-      path.coin_type=0;
-      path.account=0;
-      path.change=0;
-      path.address_index=0;
-
-      keydata::create_t cmd;
-      cmd.keyname = "superkey";
-      cmd.description = "";
-      cmd.encrypted = false;
-      cmd.cipher = keyfile_format::cipher_etype::aes256;
-      cmd.curve = keyfile_format::curve_etype::secp256k1;
-      cmd.password = pass;
-      cmd.path = fc_light::variant(path);
-//      auto variant = fc_light::variant(cmd);
-      auto json = fc_light::json::to_string(fc_light::variant(cmd));
-
-      auto mnemonics = std::move(key_data.seed(ue));
-      key_data.create_masterkey(mnemonics,pass);
-      key_data.derive_key(pass, json);
-  }
+    auto res = keychain_ref.entropy();
+
 
   keychain_invoke_f f = std::bind(&keychain_base::operator(), &keychain_ref, std::placeholders::_1);
   pipeline_parser pipe_line_parser_(std::move(f), fileno(stdin), fileno(stdout));

keychain_lib/include/keychain_lib/keychain_commands.hpp

@@ -834,15 +834,7 @@ struct keychain_command<command_te::seed>: keychain_command_base
     using  params_t = params;
     virtual std::string operator()(keychain_base* keychain, const fc_light::variant& params_variant, int id) const override
     {
-        auto param = params_variant.as<params_t>();
-        std::vector<unsigned char> entropy;
-        entropy.resize(param.entropy.length());
-        auto res = from_hex(param.entropy, entropy.data(), entropy.size());
-        entropy.resize(res);
-        //TODO: need to impl
-        std::string seed_phrase  = "witch collapse practice feed shame open despair creek road again ice least";
-        json_response response(seed_phrase, id);
-        return fc_light::json::to_string(fc_light::variant(response));
+        FC_LIGHT_THROW_EXCEPTION(fc_light::command_depreciated, "");
     }
 };
 
@@ -856,11 +848,7 @@ struct keychain_command<command_te::restore>: keychain_command_base
     using  params_t = params;
     virtual std::string operator()(keychain_base* keychain, const fc_light::variant& params_variant, int id) const override
     {
-        auto param = params_variant.as<params_t>();
-        //TODO: need to impl
-        std::string private_key  = "5fda7b741910b05738c5e0ca8961cf7a9c2f3afe8dfcae8d57df5f01690f2a02";
-        json_response response(private_key, id);
-        return fc_light::json::to_string(fc_light::variant(response));
+        FC_LIGHT_THROW_EXCEPTION(fc_light::command_depreciated, "");
     }
 };
 

keychain_lib/include/keychain_lib/keydata_singleton.hpp

@@ -16,28 +16,20 @@
 #include <boost/hana/size.hpp>
 #include "keyfile_singleton.hpp"
 
-
 namespace keychain_app {
 
-struct keydata_singleton
-{
-    static keydata_singleton& instance();
-    std::string seed(dev::bytes& );
-    void create_masterkey(std::string&, std::string&);
-    void derive_key(std::string&, std::string& );
-    void restore(const char *, std::string&, std::string& );
-    void backup(const char * );
-
-private:
-    std::pair<dev::Secret, dev::bytes> get_master_key(get_password_create_f&& );
-    keydata_singleton(){}
-    ~keydata_singleton(){}
-    std::vector<char> pbkdf2(std::string const& _pass);
-};
-
 namespace keydata
 {
 
+std::string seed(dev::bytes& );
+void derive_masterkey(std::string&, std::string&);
+void derive_key(std::string&, std::string& );
+void restore(const char *, std::string&, std::string& );
+void backup(const char * );
+std::pair<dev::Secret, dev::bytes> get_master_key(get_password_create_f&& );
+std::vector<char> pbkdf2(std::string const& _pass);
+
+
 struct path_levels_t
 {
     path_levels_t(){}
@@ -50,7 +42,6 @@ struct path_levels_t
     int address_index;
 };
 
-
 struct backup_t
 {
     backup_t(){}
@@ -108,5 +99,4 @@ FC_LIGHT_REFLECT(keychain_app::keydata::path_levels_t, (root)(purpose)(coin_type
 FC_LIGHT_REFLECT(keychain_app::keydata::create_t,  (keyname)(description)(encrypted)(cipher)(curve)(password)(path))
 FC_LIGHT_REFLECT(keychain_app::keydata::backup_t,  (keyname)(path))
 
-
 #endif //KEYCHAINAPP_KEYDATA_SINGLETON_HPP

keychain_lib/src/keydata_singleton.cpp

@@ -16,13 +16,7 @@
 
 using namespace keychain_app;
 
-keydata_singleton& keydata_singleton::instance()
-{
-    static keydata_singleton instance;
-    return instance;
-}
-
-std::string keydata_singleton::seed(dev::bytes& user_entropy)
+std::string keydata::seed(dev::bytes& user_entropy)
 {
     CryptoPP::SecByteBlock ent(16);
     CryptoPP::OS_GenerateRandomBlock(false, ent, ent.size());
@@ -68,7 +62,7 @@ std::string keydata_singleton::seed(dev::bytes& user_entropy)
 }
 
 
-std::vector<char> keydata_singleton::pbkdf2(std::string const& _pass)
+std::vector<char> keydata::pbkdf2(std::string const& _pass)
 {
     unsigned _iterations = 2048;
     unsigned _dkLen = 64;
@@ -90,7 +84,7 @@ std::vector<char> keydata_singleton::pbkdf2(std::string const& _pass)
 }
 
 
-void keydata_singleton::create_masterkey(std::string& mnemonics, std::string& pass)
+void keydata::derive_masterkey(std::string& mnemonics, std::string& pass)
 {
     std::regex re(" +");
     std::string mnemonics_ = std::regex_replace(mnemonics, re, "");
@@ -115,7 +109,7 @@ void keydata_singleton::create_masterkey(std::string& mnemonics, std::string& pa
     BOOST_LOG_SEV(log.lg, info) << "create master key";
 }
 
-void keydata_singleton::derive_key(std::string& masterkey_pass, std::string& json)
+void keydata::derive_key(std::string& masterkey_pass, std::string& json)
 {
     using namespace keydata;
     auto& log = logger_singleton::instance();
@@ -176,7 +170,7 @@ void keydata_singleton::derive_key(std::string& masterkey_pass, std::string& jso
 }
 
 
-std::pair<dev::Secret, dev::bytes> keydata_singleton::get_master_key( get_password_create_f&& get_passwd)
+std::pair<dev::Secret, dev::bytes> keydata::get_master_key( get_password_create_f&& get_passwd)
 {
     dev::Secret priv_key;
     dev::bytes chain_code;
@@ -214,7 +208,8 @@ std::pair<dev::Secret, dev::bytes> keydata_singleton::get_master_key( get_passwo
     return std::make_pair(priv_key, chain_code);
 }
 
-void keydata_singleton::restore(const char * filename, std::string& mnemonics, std::string& masterkey_pass)
+
+void keydata::restore(const char * filename, std::string& mnemonics, std::string& masterkey_pass)
 {
     using namespace keydata;
 
@@ -237,7 +232,7 @@ void keydata_singleton::restore(const char * filename, std::string& mnemonics, s
         BOOST_LOG_SEV(log.lg, info) << "restore path: " << json.back();
     }
 
-    create_masterkey(mnemonics, masterkey_pass);
+    derive_masterkey(mnemonics, masterkey_pass);
 
     for (auto &a: json)
     {
@@ -263,7 +258,7 @@ void keydata_singleton::restore(const char * filename, std::string& mnemonics, s
 }
 
 
-void keydata_singleton::backup(const char * filename)
+void keydata::backup(const char * filename)
 {
     auto file = std::ofstream(filename);
     if (!file.is_open())
@@ -275,7 +270,5 @@ void keydata_singleton::backup(const char * filename)
     auto& sql = sql_singleton::instance();
     auto backup_list = std::move(sql.select_path());
     for (auto& a : backup_list)
-        file << fc_light::json::to_pretty_string(a) << std::endl;
-
-
+        file << fc_light::json::to_string(a) << std::endl;
 }

keychain_lib/src/sql_singleton.cpp

@@ -115,7 +115,7 @@ const std::vector<keydata::backup_t> sql_singleton::select_path()
 {
     sqlite3_stmt * stmt;
     std::vector<keydata::backup_t> records;
-    const char * statement =   "select keyname, root, purpose, coin_type, account, change, address_index";
+    const char * statement =   "select keyname, root, purpose, coin_type, account, change, address_index from keypath";
 
     if  ( sqlite3_prepare_v2(db, statement, -1, &stmt, NULL) != SQLITE_OK )
         FC_LIGHT_THROW_EXCEPTION(fc_light::internal_error_exception, "sqlite3_prepare_v2");