crypto_store.hpp

Go to the documentation of this file.

#ifndef KAGOME_CRYPTO_STORE_HPP
#define KAGOME_CRYPTO_STORE_HPP

#include <memory>

#include <boost/filesystem.hpp>
#include <libp2p/crypto/key.hpp>
#include <optional>

#include "crypto/bip39/bip39_provider.hpp"
#include "crypto/crypto_store/key_type.hpp"
#include "crypto/ecdsa_types.hpp"
#include "crypto/ed25519_types.hpp"
#include "crypto/secp256k1_types.hpp"
#include "crypto/sr25519_types.hpp"

namespace kagome::crypto {
  class CryptoStore {
   public:
    // currently std::filesystem::path is missing required methods in macos SDK
    // so we have to use boost's filesystem primitives
    using Path = boost::filesystem::path;

    virtual ~CryptoStore() = default;

    using EcdsaKeys = std::vector<EcdsaPublicKey>;
    using Ed25519Keys = std::vector<Ed25519PublicKey>;
    using Sr25519Keys = std::vector<Sr25519PublicKey>;
    using EcdsaKeypairs = std::vector<EcdsaKeypair>;
    using Ed25519Keypairs = std::vector<Ed25519Keypair>;
    using Sr25519Keypairs = std::vector<Sr25519Keypair>;

    virtual outcome::result<EcdsaKeypair> generateEcdsaKeypair(
        KeyTypeId key_type, std::string_view mnemonic_phrase) = 0;

    virtual outcome::result<Ed25519Keypair> generateEd25519Keypair(
        KeyTypeId key_type, std::string_view mnemonic_phrase) = 0;

    virtual outcome::result<Sr25519Keypair> generateSr25519Keypair(
        KeyTypeId key_type, std::string_view mnemonic_phrase) = 0;

    virtual outcome::result<EcdsaKeypair> generateEcdsaKeypair(
        KeyTypeId key_type, const EcdsaSeed &seed) = 0;

    virtual outcome::result<Ed25519Keypair> generateEd25519Keypair(
        KeyTypeId key_type, const Ed25519Seed &seed) = 0;

    virtual outcome::result<Sr25519Keypair> generateSr25519Keypair(
        KeyTypeId key_type, const Sr25519Seed &seed) = 0;

    virtual outcome::result<EcdsaKeypair> generateEcdsaKeypairOnDisk(
        KeyTypeId key_type) = 0;

    virtual outcome::result<Ed25519Keypair> generateEd25519KeypairOnDisk(
        KeyTypeId key_type) = 0;

    virtual outcome::result<Sr25519Keypair> generateSr25519KeypairOnDisk(
        KeyTypeId key_type) = 0;

    virtual outcome::result<EcdsaKeypair> findEcdsaKeypair(
        KeyTypeId key_type, const EcdsaPublicKey &pk) const = 0;

    virtual outcome::result<Ed25519Keypair> findEd25519Keypair(
        KeyTypeId key_type, const Ed25519PublicKey &pk) const = 0;

    virtual outcome::result<Sr25519Keypair> findSr25519Keypair(
        KeyTypeId key_type, const Sr25519PublicKey &pk) const = 0;

    virtual outcome::result<EcdsaKeys> getEcdsaPublicKeys(
        KeyTypeId key_type) const = 0;

    virtual outcome::result<Ed25519Keys> getEd25519PublicKeys(
        KeyTypeId key_type) const = 0;

    virtual outcome::result<Sr25519Keys> getSr25519PublicKeys(
        KeyTypeId key_type) const = 0;

    virtual std::optional<libp2p::crypto::KeyPair> getLibp2pKeypair() const = 0;

    virtual outcome::result<libp2p::crypto::KeyPair> loadLibp2pKeypair(
        const Path &key_path) const = 0;
  };
}  // namespace kagome::crypto

#endif  // KAGOME_CRYPTO_STORE_HPP