Struct sp_application_crypto::ed25519::Pair

pub struct Pair(_);

A key pair.

Implementations

impl Pair

pub fn seed(&self) -> &[u8; 32]

Get the seed for this key.

pub fn from_legacy_string(s: &str, password_override: Option<&str>) -> Pair

Exactly as from_string except that if no matches are found then, the the first 32 characters are taken (padded with spaces as necessary) and used as the MiniSecretKey.

Trait Implementations

impl AsMut<Pair> for Pair

pub fn as_mut(&mut self) -> &mut Pair

Performs the conversion.

impl AsRef<Pair> for Pair

pub fn as_ref(&self) -> &Pair

Performs the conversion.

impl Clone for Pair

pub fn clone(&self) -> Pair

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CryptoType for Pair

type Pair = Pair

The pair key type of this crypto.

impl From<Pair> for Public

pub fn from(x: Pair) -> Public

Performs the conversion.

impl From<Pair> for Pair

pub fn from(inner: Pair) -> Self

Performs the conversion.

impl From<Pair> for Pair

pub fn from(outer: Pair) -> Self

Performs the conversion.

impl Pair for Pair

type Public = Public

The type which is used to encode a public key.

type Seed = [u8; 32]

The type used to (minimally) encode the data required to securely create a new key pair.

type Signature = Signature

The type used to represent a signature. Can be created from a key pair and a message and verified with the message and a public key.

type DeriveError = DeriveError

Error returned from the derive function.

pub fn generate_with_phrase(password: Option<&str>) -> (Pair, String, [u8; 32])

Generate new secure (random) key pair and provide the recovery phrase.

You can recover the same key later with from_phrase.

pub fn from_phrase(
    phrase: &str,
    password: Option<&str>
) -> Result<(Pair, [u8; 32]), SecretStringError>

Generate key pair from given recovery phrase and password.

pub fn from_seed(seed: &[u8; 32]) -> Pair

Make a new key pair from secret seed material.

You should never need to use this; generate(), generate_with_phrase

pub fn from_seed_slice(seed_slice: &[u8]) -> Result<Pair, SecretStringError>

Make a new key pair from secret seed material. The slice must be 32 bytes long or it will return None.

You should never need to use this; generate(), generate_with_phrase

pub fn derive<Iter>(
    &self,
    path: Iter,
    _seed: Option<[u8; 32]>
) -> Result<(Pair, Option<[u8; 32]>), DeriveError> where
    Iter: Iterator<Item = DeriveJunction>, 

Derive a child key from a series of given junctions.

pub fn public(&self) -> Public

Get the public key.

pub fn sign(&self, message: &[u8]) -> Signature

Sign a message.

pub fn verify<M>(
    sig: &<Pair as Pair>::Signature,
    message: M,
    pubkey: &<Pair as Pair>::Public
) -> bool where
    M: AsRef<[u8]>, 

Verify a signature on a message. Returns true if the signature is good.

pub fn verify_weak<P, M>(sig: &[u8], message: M, pubkey: P) -> bool where
    M: AsRef<[u8]>,
    P: AsRef<[u8]>, 

Verify a signature on a message. Returns true if the signature is good.

This doesn't use the type system to ensure that sig and pubkey are the correct size. Use it only if you're coming from byte buffers and need the speed.

pub fn to_raw_vec(&self) -> Vec<u8, Global>

Return a vec filled with raw data.

pub fn generate() -> (Self, Self::Seed)

Generate new secure (random) key pair.

pub fn from_string_with_seed(
    s: &str,
    password_override: Option<&str>
) -> Result<(Self, Option<Self::Seed>), SecretStringError>

Interprets the string s in order to generate a key Pair. Returns both the pair and an optional seed, in the case that the pair can be expressed as a direct derivation from a seed (some cases, such as Sr25519 derivations with path components, cannot).

pub fn from_string(
    s: &str,
    password_override: Option<&str>
) -> Result<Self, SecretStringError>

Interprets the string s in order to generate a key pair.