Trait KeyCodec 

pub trait KeyCodec {
    type Pair: PairTrait;
    type PrivateKey: Clone;
    type PublicKey: Clone;
    type Address;

    const KEY_TYPE: &'static str;

    // Required methods
    fn derive_public(private_key: &Self::PrivateKey) -> Self::PublicKey;
    fn derive_address(public_key: &Self::PublicKey) -> Result<Self::Address>;
    fn encode_private(private_key: &Self::PrivateKey) -> Result<String>;
    fn decode_private(encoded: &str) -> Result<Self::PrivateKey>;
    fn encode_public(public_key: &Self::PublicKey) -> Result<String>;
    fn decode_public(encoded: &str) -> Result<Self::PublicKey>;
    fn encode_address(address: &Self::Address) -> Result<String>;
    fn decode_address(encoded: &str) -> Result<Self::Address>;
    fn random_private() -> Result<Self::PrivateKey>;
    fn import_suri(
        suri: &str,
        password: Option<&str>,
    ) -> Result<Self::PrivateKey>;
}

Trait describing how to convert to and from string representations for key material, and how to generate/import keys for keyring operations.

Required Associated Constants

const KEY_TYPE: &'static str

Human-readable key type identifier (e.g., “ecdsa”, “sr25519”, “ed25519”).

Required Associated Types

type Pair: PairTrait

Concrete Substrate pair type.

type PrivateKey: Clone

Private key wrapper type.

type PublicKey: Clone

Public key wrapper type.

type Address

Address type exposed by the scheme.

Required Methods

fn derive_public(private_key: &Self::PrivateKey) -> Self::PublicKey

Derive the public key from the provided private key.

fn derive_address(public_key: &Self::PublicKey) -> Result<Self::Address>

Derive the address from the provided public key.

fn encode_private(private_key: &Self::PrivateKey) -> Result<String>

Encode private key for storage.

fn decode_private(encoded: &str) -> Result<Self::PrivateKey>

Decode private key from storage.

fn encode_public(public_key: &Self::PublicKey) -> Result<String>

Encode public key for storage.

fn decode_public(encoded: &str) -> Result<Self::PublicKey>

Decode public key from storage.

fn encode_address(address: &Self::Address) -> Result<String>

Encode address for storage.

fn decode_address(encoded: &str) -> Result<Self::Address>

Decode address from storage.

fn random_private() -> Result<Self::PrivateKey>

Generate a new random private key.

fn import_suri(suri: &str, password: Option<&str>) -> Result<Self::PrivateKey>

Import a private key from a SURI (mnemonic/derivation path).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl KeyCodec for Ed25519Codec

const KEY_TYPE: &'static str = "ed25519"

type Pair = Pair

type PrivateKey = PrivateKey

type PublicKey = PublicKey

type Address = SubstrateAddress

impl KeyCodec for Secp256k1Codec

const KEY_TYPE: &'static str = "ecdsa"

type Pair = Pair

type PrivateKey = PrivateKey

type PublicKey = PublicKey

type Address = Address

impl KeyCodec for Sr25519Codec

const KEY_TYPE: &'static str = "sr25519"

type Pair = Pair

type PrivateKey = PrivateKey

type PublicKey = PublicKey

type Address = SubstrateAddress