Struct Keypair 

pub struct Keypair { /* private fields */ }

Implementations

impl Keypair

pub fn pair_is_some(&self) -> bool

Returns whether this keypair has an active key pair.

pub fn new( ss58_address: Option<String>, public_key: Option<String>, private_key: Option<String>, ss58_format: u8, seed_hex: Option<Vec<u8>>, crypto_type: u8, ) -> Result<Self, String>

Creates a new Keypair instance.

    Arguments:
        ss58_address (Option<String>): Optional SS58-formatted address.
        public_key (Option<String>): Optional public key as hex string.
        private_key (Option<String>): Optional private key as hex string.
        ss58_format (u8): The SS58 format number for address encoding.
        seed_hex (Option<Vec<u8>>): Optional seed bytes.
        crypto_type (u8): The cryptographic algorithm type. 0 for ED25519, 1 for SR25519.
    Returns:
        keypair (Keypair): A new Keypair instance.

pub fn generate_mnemonic(n_words: usize) -> Result<String, String>

Generates a new mnemonic phrase.

    Arguments:
        n_words (usize): The number of words in the mnemonic (e.g., 12, 15, 18, 21, 24).
    Returns:
        mnemonic (String): The generated mnemonic phrase.

pub fn create_from_mnemonic( mnemonic: &str, crypto_type: u8, ) -> Result<Self, String>

Creates a Keypair from a mnemonic phrase.

    Arguments:
        mnemonic (str): The mnemonic phrase to create the keypair from.
        crypto_type (u8): The cryptographic algorithm type. 0 for ED25519, 1 for SR25519.
    Returns:
        keypair (Keypair): The Keypair created from the mnemonic.

pub fn create_from_seed(seed: Vec<u8>, crypto_type: u8) -> Result<Self, String>

Creates a Keypair from a seed.

    Arguments:
        seed (Vec<u8>): The seed bytes to create the keypair from.
        crypto_type (u8): The cryptographic algorithm type. 0 for ED25519, 1 for SR25519.
    Returns:
        keypair (Keypair): The Keypair created from the seed.

pub fn create_from_private_key( private_key: &str, crypto_type: u8, ) -> Result<Self, String>

Creates a Keypair from a private key.

    Arguments:
        private_key (str): The private key as hex string to create the keypair from.
        crypto_type (u8): The cryptographic algorithm type. 0 for ED25519, 1 for SR25519.
    Returns:
        keypair (Keypair): The Keypair created from the private key.

pub fn create_from_encrypted_json( json_data: &str, passphrase: &str, ) -> Result<Keypair, String>

Creates a Keypair from encrypted JSON data.

    Arguments:
        json_data (str): The encrypted JSON data containing the keypair.
        passphrase (str): The passphrase to decrypt the JSON data.
    Returns:
        keypair (Keypair): The Keypair created from the encrypted JSON.

pub fn create_from_uri(uri: &str, crypto_type: u8) -> Result<Self, String>

Creates a Keypair from a URI string.

    Arguments:
        uri (str): The URI string to create the keypair from.
        crypto_type (u8): The cryptographic algorithm type. 0 for ED25519, 1 for SR25519.
    Returns:
        keypair (Keypair): The Keypair created from the URI.

pub fn sign(&self, data: Vec<u8>) -> Result<Vec<u8>, String>

Signs data with the keypair’s private key.

    Arguments:
        data (Vec<u8>): The data to sign as bytes.
    Returns:
        signature (Vec<u8>): The signature as bytes.

pub fn verify(&self, data: Vec<u8>, signature: Vec<u8>) -> Result<bool, String>

Verifies a signature against data using the keypair’s public key.

    Arguments:
        data (Vec<u8>): The data that was signed as bytes.
        signature (Vec<u8>): The signature to verify as bytes.
    Returns:
        verified (bool): ``True`` if the signature is valid, ``False`` otherwise.

pub fn encrypt(&self, message: &[u8]) -> Result<Vec<u8>, String>

Encrypts a message using the recipient’s ED25519 public key (sealed box).

    Arguments:
        message (&[u8]): The plaintext message to encrypt.
    Returns:
        ciphertext (Vec<u8>): The encrypted message (48 bytes longer than the input).

pub fn decrypt(&self, ciphertext: &[u8]) -> Result<Vec<u8>, String>

Decrypts a sealed box ciphertext using the keypair’s ED25519 private key.

    Arguments:
        ciphertext (&[u8]): The encrypted message to decrypt.
    Returns:
        plaintext (Vec<u8>): The decrypted message.

pub fn ss58_address(&self) -> Option<String>

Returns the SS58 address of the keypair.

pub fn public_key(&self) -> Result<Option<Vec<u8>>, String>

Returns the public key of the keypair as bytes.

pub fn ss58_format(&self) -> u8

Returns the SS58 format number.

pub fn seed_hex(&self) -> Option<Vec<u8>>

Returns the seed bytes used to derive this keypair, if known.

pub fn crypto_type(&self) -> u8

Returns the cryptographic algorithm type. Derives from the inner pair if present; falls back to the stored field for pub-only keypairs.

pub fn mnemonic(&self) -> Option<String>

Returns the mnemonic phrase of the keypair.

pub fn private_key(&self) -> Result<Option<Vec<u8>>, String>

Returns the private key of the keypair as bytes.

Trait Implementations

impl Clone for Keypair

fn clone(&self) -> Keypair

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Keypair

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Keypair

fn default() -> Self

Returns the “default value” for a type.

impl Display for Keypair

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.