Struct sc_keystore::LocalKeystore

pub struct LocalKeystore(_);

A local based keystore that is either memory-based or filesystem-based.

Implementations

impl LocalKeystore

pub fn open<T: Into<PathBuf>>(
    path: T,
    password: Option<SecretString>
) -> Result<Self>

Create a local keystore from filesystem.

pub fn in_memory() -> Self

Create a local keystore in memory.

pub fn key_pair<Pair: AppPair>(
    &self,
    public: &<Pair as AppKey>::Public
) -> Result<Option<Pair>>

Get a key pair for the given public key.

Returns Ok(None) if the key doesn’t exist, Ok(Some(_)) if the key exists and Err(_) when something failed.

Trait Implementations

impl CryptoStore for LocalKeystore

fn keys<'life0, 'async_trait>(
    &'life0 self,
    id: KeyTypeId
) -> Pin<Box<dyn Future<Output = Result<Vec<CryptoTypePublicPair>, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

List all supported keys

fn sr25519_public_keys<'life0, 'async_trait>(
    &'life0 self,
    id: KeyTypeId
) -> Pin<Box<dyn Future<Output = Vec<Public>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns all sr25519 public keys for the given key type.

fn sr25519_generate_new<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    seed: Option<&'life1 str>
) -> Pin<Box<dyn Future<Output = Result<Public, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Generate a new sr25519 key pair for the given key type and an optional seed.

fn ed25519_public_keys<'life0, 'async_trait>(
    &'life0 self,
    id: KeyTypeId
) -> Pin<Box<dyn Future<Output = Vec<Public>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns all ed25519 public keys for the given key type.

fn ed25519_generate_new<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    seed: Option<&'life1 str>
) -> Pin<Box<dyn Future<Output = Result<Public, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Generate a new ed25519 key pair for the given key type and an optional seed.

fn ecdsa_public_keys<'life0, 'async_trait>(
    &'life0 self,
    id: KeyTypeId
) -> Pin<Box<dyn Future<Output = Vec<Public>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns all ecdsa public keys for the given key type.

fn ecdsa_generate_new<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    seed: Option<&'life1 str>
) -> Pin<Box<dyn Future<Output = Result<Public, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Generate a new ecdsa key pair for the given key type and an optional seed.

fn insert_unknown<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    suri: &'life1 str,
    public: &'life2 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), ()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Insert a new key. This doesn’t require any known of the crypto; but a public key must be manually provided.

fn has_keys<'life0, 'life1, 'async_trait>(
    &'life0 self,
    public_keys: &'life1 [(Vec<u8>, KeyTypeId)]
) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Checks if the private keys for the given public key and key type combinations exist.

fn supported_keys<'life0, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    keys: Vec<CryptoTypePublicPair>
) -> Pin<Box<dyn Future<Output = Result<Vec<CryptoTypePublicPair>, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Find intersection between provided keys and supported keys

fn sign_with<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    key: &'life1 CryptoTypePublicPair,
    msg: &'life2 [u8]
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Sign with key

fn sr25519_vrf_sign<'life0, 'life1, 'async_trait>(
    &'life0 self,
    key_type: KeyTypeId,
    public: &'life1 Public,
    transcript_data: VRFTranscriptData
) -> Pin<Box<dyn Future<Output = Result<Option<VRFSignature>, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Generate VRF signature for given transcript data.

fn ecdsa_sign_prehashed<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    public: &'life1 Public,
    msg: &'life2 [u8; 32]
) -> Pin<Box<dyn Future<Output = Result<Option<Signature>, TraitError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Generate an ECDSA signature for a given pre-hashed message.

fn sign_with_any<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    keys: Vec<CryptoTypePublicPair, Global>,
    msg: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<Option<(CryptoTypePublicPair, Vec<u8, Global>)>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Sign with any key

fn sign_with_all<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: KeyTypeId,
    keys: Vec<CryptoTypePublicPair, Global>,
    msg: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<Vec<Result<Option<Vec<u8, Global>>, Error>, Global>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Sign with all keys

impl Into<Arc<dyn CryptoStore + 'static>> for LocalKeystore

fn into(self) -> Arc<dyn CryptoStore>

Converts this type into the (usually inferred) input type.

impl Into<Arc<dyn SyncCryptoStore + 'static>> for LocalKeystore

fn into(self) -> SyncCryptoStorePtr

Converts this type into the (usually inferred) input type.

impl SyncCryptoStore for LocalKeystore

fn keys(&self, id: KeyTypeId) -> Result<Vec<CryptoTypePublicPair>, TraitError>

List all supported keys

fn supported_keys(
    &self,
    id: KeyTypeId,
    keys: Vec<CryptoTypePublicPair>
) -> Result<Vec<CryptoTypePublicPair>, TraitError>

Find intersection between provided keys and supported keys

fn sign_with(
    &self,
    id: KeyTypeId,
    key: &CryptoTypePublicPair,
    msg: &[u8]
) -> Result<Option<Vec<u8>>, TraitError>

Sign with key

fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<Public>

Returns all sr25519 public keys for the given key type.

fn sr25519_generate_new(
    &self,
    id: KeyTypeId,
    seed: Option<&str>
) -> Result<Public, TraitError>

Generate a new sr25519 key pair for the given key type and an optional seed.

fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<Public>

Returns all ed25519 public keys for the given key type.

fn ed25519_generate_new(
    &self,
    id: KeyTypeId,
    seed: Option<&str>
) -> Result<Public, TraitError>

Generate a new ed25519 key pair for the given key type and an optional seed.

fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<Public>

Returns all ecdsa public keys for the given key type.

fn ecdsa_generate_new(
    &self,
    id: KeyTypeId,
    seed: Option<&str>
) -> Result<Public, TraitError>

Generate a new ecdsa key pair for the given key type and an optional seed.

fn insert_unknown(
    &self,
    key_type: KeyTypeId,
    suri: &str,
    public: &[u8]
) -> Result<(), ()>

Insert a new key. This doesn’t require any known of the crypto; but a public key must be manually provided.

fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool

Checks if the private keys for the given public key and key type combinations exist.

fn sr25519_vrf_sign(
    &self,
    key_type: KeyTypeId,
    public: &Sr25519Public,
    transcript_data: VRFTranscriptData
) -> Result<Option<VRFSignature>, TraitError>

Generate VRF signature for given transcript data.

fn ecdsa_sign_prehashed(
    &self,
    id: KeyTypeId,
    public: &Public,
    msg: &[u8; 32]
) -> Result<Option<Signature>, TraitError>

Generate an ECDSA signature for a given pre-hashed message.

fn sign_with_any(
    &self,
    id: KeyTypeId,
    keys: Vec<CryptoTypePublicPair, Global>,
    msg: &[u8]
) -> Result<Option<(CryptoTypePublicPair, Vec<u8, Global>)>, Error>

Sign with any key

fn sign_with_all(
    &self,
    id: KeyTypeId,
    keys: Vec<CryptoTypePublicPair, Global>,
    msg: &[u8]
) -> Result<Vec<Result<Option<Vec<u8, Global>>, Error>, Global>, ()>

Sign with all keys