Refactor key store

core/api/CMakeLists.txt

@@ -57,7 +57,7 @@ target_link_libraries(api
     logger
     app_state_manager
     p2p::p2p_peer_id
-    crypto_store
+    key_store
     hexutil
     scale::scale
     storage

core/api/service/author/author_api.hpp

@@ -10,7 +10,7 @@
 #include "common/buffer.hpp"
 #include "common/buffer_view.hpp"
 #include "crypto/common.hpp"
-#include "crypto/crypto_store/key_type.hpp"
+#include "crypto/key_store/key_type.hpp"
 #include "primitives/author_api_primitives.hpp"
 #include "primitives/transaction_validity.hpp"
 

core/api/service/author/impl/author_api_impl.cpp

@@ -13,12 +13,11 @@
 
 #include "api/service/api_service.hpp"
 #include "blockchain/block_tree.hpp"
-#include "crypto/crypto_store.hpp"
-#include "crypto/crypto_store/crypto_store_impl.hpp"
-#include "crypto/crypto_store/crypto_suites.hpp"
-#include "crypto/crypto_store/key_file_storage.hpp"
-#include "crypto/crypto_store/session_keys.hpp"
 #include "crypto/hasher.hpp"
+#include "crypto/key_store.hpp"
+#include "crypto/key_store/key_file_storage.hpp"
+#include "crypto/key_store/session_keys.hpp"
+#include "crypto/sr25519_types.hpp"
 #include "primitives/transaction.hpp"
 #include "runtime/runtime_api/session_keys_api.hpp"
 #include "scale/scale_decoder_stream.hpp"
@@ -34,7 +33,7 @@ namespace kagome::api {
 
   AuthorApiImpl::AuthorApiImpl(sptr<runtime::SessionKeysApi> key_api,
                                sptr<transaction_pool::TransactionPool> pool,
-                               sptr<crypto::CryptoStore> store,
+                               sptr<crypto::KeyStore> store,
                                sptr<crypto::SessionKeys> keys,
                                sptr<crypto::KeyFileStorage> key_store,
                                LazySPtr<blockchain::BlockTree> block_tree,
@@ -68,33 +67,33 @@ namespace kagome::api {
         == kKeyTypes.end()) {
       std::string types;
       for (auto &type : kKeyTypes) {
-        types.append(crypto::encodeKeyTypeToStr(type));
+        types.append(type.toString());
         types.push_back(' ');
       }
       types.pop_back();
       SL_INFO(logger_, "Unsupported key type, only [{}] are accepted", types);
-      return outcome::failure(crypto::CryptoStoreError::UNSUPPORTED_KEY_TYPE);
+      return outcome::failure(crypto::KeyStoreError::UNSUPPORTED_KEY_TYPE);
     };
     if (crypto::KeyTypes::BABE == key_type_id
         or crypto::KeyTypes::AUTHORITY_DISCOVERY == key_type_id) {
-      OUTCOME_TRY(seed_typed, crypto::Sr25519Seed::from(seed));
       OUTCOME_TRY(public_key_typed,
                   crypto::Sr25519PublicKey::fromSpan(public_key));
+      OUTCOME_TRY(seed_typed, crypto::Sr25519Seed::from(std::move(seed)));
       OUTCOME_TRY(keypair,
-                  store_->generateSr25519Keypair(key_type_id, seed_typed));
+                  store_->sr25519().generateKeypair(key_type_id, seed_typed));
       if (public_key_typed != keypair.public_key) {
-        return outcome::failure(crypto::CryptoStoreError::WRONG_PUBLIC_KEY);
+        return outcome::failure(crypto::KeyStoreError::WRONG_PUBLIC_KEY);
       }
     }
     if (crypto::KeyTypes::GRANDPA == key_type_id) {
-      OUTCOME_TRY(seed_typed, crypto::Ed25519Seed::from(seed));
       OUTCOME_TRY(public_key_typed,
                   crypto::Ed25519PublicKey::fromSpan(public_key));
+      OUTCOME_TRY(seed_typed, crypto::Ed25519Seed::from(std::move(seed)));
       OUTCOME_TRY(keypair,
-                  store_->generateEd25519Keypair(crypto::KeyTypes::GRANDPA,
-                                                 seed_typed));
+                  store_->ed25519().generateKeypair(crypto::KeyTypes::GRANDPA,
+                                                    seed_typed));
       if (public_key_typed != keypair.public_key) {
-        return outcome::failure(crypto::CryptoStoreError::WRONG_PUBLIC_KEY);
+        return outcome::failure(crypto::KeyStoreError::WRONG_PUBLIC_KEY);
       }
     }
     auto res =
@@ -123,13 +122,13 @@ namespace kagome::api {
       return false;
     }
     stream >> key;
-    if (store_->findEd25519Keypair(
+    if (store_->ed25519().findKeypair(
             crypto::KeyTypes::GRANDPA,
             crypto::Ed25519PublicKey(common::Blob<32>(key)))) {
       unsigned count = 1;
       while (stream.currentIndex() < keys.size()) {
         stream >> key;
-        if (not store_->findSr25519Keypair(
+        if (not store_->sr25519().findKeypair(
                 crypto::polkadot_key_order[count++],
                 crypto::Sr25519PublicKey(common::Blob<32>(key)))) {
           return false;
@@ -142,12 +141,11 @@ namespace kagome::api {
 
   outcome::result<bool> AuthorApiImpl::hasKey(const BufferView &public_key,
                                               crypto::KeyType key_type) {
-    auto res = key_store_->searchForPhrase(key_type, public_key);
+    auto res = key_store_->searchForKey(key_type, public_key);
     if (not res) {
       return res.error();
-    } else {
-      return res.value() ? true : false;
     }
+    return res.value();
   }
 
   outcome::result<std::vector<primitives::Extrinsic>>

core/api/service/author/impl/author_api_impl.hpp

@@ -30,7 +30,7 @@ namespace kagome::blockchain {
   class BlockTree;
 }
 namespace kagome::crypto {
-  class CryptoStore;
+  class KeyStore;
   class Hasher;
   class KeyFileStorage;
   class SessionKeys;
@@ -70,7 +70,7 @@ namespace kagome::api {
      */
     AuthorApiImpl(sptr<runtime::SessionKeysApi> key_api,
                   sptr<transaction_pool::TransactionPool> pool,
-                  sptr<crypto::CryptoStore> store,
+                  sptr<crypto::KeyStore> store,
                   sptr<crypto::SessionKeys> keys,
                   sptr<crypto::KeyFileStorage> key_store,
                   LazySPtr<blockchain::BlockTree> block_tree,
@@ -108,7 +108,7 @@ namespace kagome::api {
    private:
     sptr<runtime::SessionKeysApi> keys_api_;
     sptr<transaction_pool::TransactionPool> pool_;
-    sptr<crypto::CryptoStore> store_;
+    sptr<crypto::KeyStore> store_;
     sptr<crypto::SessionKeys> keys_;
     sptr<crypto::KeyFileStorage> key_store_;
     LazySPtr<api::ApiService> api_service_;

core/api/service/author/requests/has_key.hpp

@@ -10,6 +10,7 @@
 
 #include "api/service/author/author_api.hpp"
 #include "api/service/base_request.hpp"
+#include "crypto/key_store/key_type.hpp"
 #include "outcome/outcome.hpp"
 
 namespace kagome::api::author::request {
@@ -23,8 +24,10 @@ namespace kagome::api::author::request {
 
     outcome::result<Return> execute() override {
       OUTCOME_TRY(public_key, common::unhexWith0x(getParam<0>()));
-      return api_->hasKey(public_key,
-                          crypto::decodeKeyTypeFromStr(getParam<1>()));
+      if (auto key_type = crypto::KeyType::fromString(getParam<1>())) {
+        return api_->hasKey(public_key, *key_type);
+      }
+      return crypto::KeyTypeError::UNSUPPORTED_KEY_TYPE;
     }
 
    private:

core/api/service/author/requests/insert_key.hpp

@@ -11,6 +11,7 @@
 #include "api/service/author/author_api.hpp"
 #include "api/service/base_request.hpp"
 #include "crypto/common.hpp"
+#include "crypto/key_store/key_type.hpp"
 #include "outcome/outcome.hpp"
 
 namespace kagome::api::author::request {
@@ -33,9 +34,10 @@ namespace kagome::api::author::request {
           std::string_view{seed_hex.data(), seed_hex.size()},
           seed_buf.begin()));
       OUTCOME_TRY(public_key, common::unhexWith0x(getParam<2>()));
-      return api_->insertKey(crypto::decodeKeyTypeFromStr(getParam<0>()),
-                             std::move(seed_buf),
-                             public_key);
+      if (auto key_type = crypto::KeyType::fromString(getParam<0>())) {
+        return api_->insertKey(*key_type, std::move(seed_buf), public_key);
+      }
+      return crypto::KeyTypeError::UNSUPPORTED_KEY_TYPE;
     }
 
    private:

core/authority_discovery/publisher/address_publisher.hpp

@@ -8,7 +8,7 @@
 
 #include "application/app_state_manager.hpp"
 #include "blockchain/block_tree.hpp"
-#include "crypto/crypto_store/session_keys.hpp"
+#include "crypto/key_store/session_keys.hpp"
 #include "crypto/ed25519_provider.hpp"
 #include "crypto/sr25519_provider.hpp"
 #include "log/logger.hpp"

core/authority_discovery/query/query_impl.cpp

@@ -36,7 +36,7 @@ namespace kagome::authority_discovery {
       std::shared_ptr<application::AppStateManager> app_state_manager,
       std::shared_ptr<blockchain::BlockTree> block_tree,
       std::shared_ptr<runtime::AuthorityDiscoveryApi> authority_discovery_api,
-      std::shared_ptr<crypto::CryptoStore> crypto_store,
+      std::shared_ptr<crypto::KeyStore> key_store,
       std::shared_ptr<crypto::Sr25519Provider> sr_crypto_provider,
       std::shared_ptr<libp2p::crypto::CryptoProvider> libp2p_crypto_provider,
       std::shared_ptr<libp2p::crypto::marshaller::KeyMarshaller> key_marshaller,
@@ -45,7 +45,7 @@ namespace kagome::authority_discovery {
       std::shared_ptr<libp2p::basic::Scheduler> scheduler)
       : block_tree_{std::move(block_tree)},
         authority_discovery_api_{std::move(authority_discovery_api)},
-        crypto_store_{std::move(crypto_store)},
+        key_store_{std::move(key_store)},
         sr_crypto_provider_{std::move(sr_crypto_provider)},
         libp2p_crypto_provider_{std::move(libp2p_crypto_provider)},
         key_marshaller_{std::move(key_marshaller)},
@@ -101,7 +101,7 @@ namespace kagome::authority_discovery {
         authorities,
         authority_discovery_api_->authorities(block_tree_->bestBlock().hash));
     OUTCOME_TRY(local_keys,
-                crypto_store_->getSr25519PublicKeys(
+                key_store_->sr25519().getPublicKeys(
                     crypto::KeyTypes::AUTHORITY_DISCOVERY));
     auto has = [](const std::vector<primitives::AuthorityDiscoveryId> &keys,
                   const primitives::AuthorityDiscoveryId &key) {

core/authority_discovery/query/query_impl.hpp

@@ -11,7 +11,7 @@
 #include "application/app_state_manager.hpp"
 #include "authority_discovery/interval.hpp"
 #include "blockchain/block_tree.hpp"
-#include "crypto/crypto_store.hpp"
+#include "crypto/key_store.hpp"
 #include "crypto/sr25519_provider.hpp"
 #include "log/logger.hpp"
 #include "runtime/runtime_api/authority_discovery_api.hpp"
@@ -38,7 +38,7 @@ namespace kagome::authority_discovery {
         std::shared_ptr<application::AppStateManager> app_state_manager,
         std::shared_ptr<blockchain::BlockTree> block_tree,
         std::shared_ptr<runtime::AuthorityDiscoveryApi> authority_discovery_api,
-        std::shared_ptr<crypto::CryptoStore> crypto_store,
+        std::shared_ptr<crypto::KeyStore> key_store,
         std::shared_ptr<crypto::Sr25519Provider> sr_crypto_provider,
         std::shared_ptr<libp2p::crypto::CryptoProvider> libp2p_crypto_provider,
         std::shared_ptr<libp2p::crypto::marshaller::KeyMarshaller>
@@ -64,7 +64,7 @@ namespace kagome::authority_discovery {
 
     std::shared_ptr<blockchain::BlockTree> block_tree_;
     std::shared_ptr<runtime::AuthorityDiscoveryApi> authority_discovery_api_;
-    std::shared_ptr<crypto::CryptoStore> crypto_store_;
+    std::shared_ptr<crypto::KeyStore> key_store_;
     std::shared_ptr<crypto::Sr25519Provider> sr_crypto_provider_;
     std::shared_ptr<libp2p::crypto::CryptoProvider> libp2p_crypto_provider_;
     std::shared_ptr<libp2p::crypto::marshaller::KeyMarshaller> key_marshaller_;

core/common/bytestr.hpp

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <string>
 #include <string_view>
 #include <vector>
 
@@ -19,6 +20,11 @@ namespace kagome {
     return {reinterpret_cast<const uint8_t *>(s.data()), s.size()};
   }
 
+  inline std::span<uint8_t> str2byte(std::span<char> s) {
+    // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    return {reinterpret_cast<uint8_t *>(s.data()), s.size()};
+  }
+
   inline std::string_view byte2str(const common::BufferView &s) {
     // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
     return {reinterpret_cast<const char *>(s.data()), s.size()};

core/common/optref.hpp

@@ -0,0 +1,75 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace kagome {
+  template <typename T>
+  class OptRef {
+   public:
+    OptRef() : data{nullptr} {}
+    OptRef(T &data) : data{&data} {}
+    OptRef(T &&) = delete;
+    OptRef(std::nullopt_t) : data{nullptr} {}
+
+    OptRef(const OptRef &) = default;
+
+    OptRef &operator=(const OptRef &) = default;
+
+    T &operator*() {
+      BOOST_ASSERT(data);
+      return *data;
+    }
+
+    const T &operator*() const {
+      BOOST_ASSERT(data);
+      return *data;
+    }
+
+    T *operator->() {
+      BOOST_ASSERT(data);
+      return data;
+    }
+
+    const T *operator->() const {
+      BOOST_ASSERT(data);
+      return data;
+    }
+
+    T &value() {
+      BOOST_ASSERT(data);
+      return *data;
+    }
+
+    const T &value() const {
+      BOOST_ASSERT(data);
+      return *data;
+    }
+
+    explicit operator bool() const noexcept {
+      return data != nullptr;
+    }
+
+    bool operator!() const noexcept {
+      return data == nullptr;
+    }
+
+    bool has_value() const noexcept {
+      return data != nullptr;
+    }
+
+    bool operator==(const OptRef<T> &) const = default;
+
+    bool operator==(const T &other) const {
+      return has_value() && (*data == other);
+    }
+
+   private:
+    T *data;
+  };
+}  // namespace kagome

core/consensus/babe/impl/babe.cpp

@@ -26,7 +26,7 @@
 #include "consensus/timeline/impl/slot_leadership_error.hpp"
 #include "consensus/timeline/slots_util.hpp"
 #include "crypto/blake2/blake2b.h"
-#include "crypto/crypto_store/session_keys.hpp"
+#include "crypto/key_store/session_keys.hpp"
 #include "crypto/sr25519_provider.hpp"
 #include "dispute_coordinator/dispute_coordinator.hpp"
 #include "metrics/histogram_timer.hpp"

core/consensus/babe/impl/babe_lottery_impl.cpp

@@ -9,7 +9,7 @@
 #include "consensus/babe/babe_config_repository.hpp"
 #include "consensus/babe/impl/prepare_transcript.hpp"
 #include "consensus/babe/impl/threshold_util.hpp"
-#include "crypto/crypto_store/session_keys.hpp"
+#include "crypto/key_store/session_keys.hpp"
 #include "crypto/hasher.hpp"
 #include "crypto/vrf_provider.hpp"
 

core/consensus/beefy/impl/beefy_impl.cpp

@@ -18,7 +18,7 @@
 #include "consensus/beefy/impl/beefy_thread_pool.hpp"
 #include "consensus/beefy/sig.hpp"
 #include "consensus/timeline/timeline.hpp"
-#include "crypto/crypto_store/session_keys.hpp"
+#include "crypto/key_store/session_keys.hpp"
 #include "metrics/histogram_timer.hpp"
 #include "network/impl/protocols/beefy_protocol_impl.hpp"
 #include "runtime/common/runtime_execution_error.hpp"