Struct sp_core::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 Clone for Pair

fn clone(&self) -> Self

Returns a copy of the value.

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

fn from(x: Pair) -> Self

Performs the conversion.

impl Pair for Pair

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.

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

Generate key pair from given recovery phrase and password.

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

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

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

Derive a child key from a series of given junctions.

fn public(&self) -> Public

Get the public key.

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

Sign a message.

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

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

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

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.

fn to_raw_vec(&self) -> Vec<u8>

Return a vec filled with raw data.

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.

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

Generate new secure (random) key pair.

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).

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

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