Struct secp256k1::KeyPair

pub struct KeyPair(_);

Opaque data structure that holds a keypair consisting of a secret and a public key.

Serde support

Implements de/serialization with the serde and_global-context features enabled. Serializes the secret bytes only. We treat the byte value as a tuple of 32 u8s for non-human-readable formats. This representation is optimal for for some formats (e.g. bincode) however other formats may be less optimal (e.g. cbor). For human-readable formats we use a hex string.

Examples

Basic usage:

use secp256k1::{rand, KeyPair, Secp256k1};

let secp = Secp256k1::new();
let (secret_key, public_key) = secp.generate_keypair(&mut rand::thread_rng());
let key_pair = KeyPair::from_secret_key(&secp, &secret_key);

Implementations

impl KeyPair

pub fn display_secret(&self) -> DisplaySecret

Formats the explicit byte value of the secret key kept inside the type as a little-endian hexadecimal string using the provided formatter.

This is the only method that outputs the actual secret key value, and, thus, should be used with extreme precaution.

Example

use secp256k1::ONE_KEY;
use secp256k1::KeyPair;
use secp256k1::Secp256k1;

let secp = Secp256k1::new();
let key = ONE_KEY;
let key = KeyPair::from_secret_key(&secp, &key);
// Here we explicitly display the secret value:
assert_eq!(
    "0000000000000000000000000000000000000000000000000000000000000001",
    format!("{}", key.display_secret())
);
// Also, we can explicitly display with `Debug`:
assert_eq!(
    format!("{:?}", key.display_secret()),
    format!("DisplaySecret(\"{}\")", key.display_secret())
);

impl KeyPair

pub fn as_ptr(&self) -> *const KeyPair

Obtains a raw const pointer suitable for use with FFI functions.

pub fn as_mut_ptr(&mut self) -> *mut KeyPair

Obtains a raw mutable pointer suitable for use with FFI functions.

pub fn from_secret_key<C: Signing>(
    secp: &Secp256k1<C>,
    sk: &SecretKey
) -> KeyPair

Creates a KeyPair directly from a Secp256k1 secret key.

pub fn from_seckey_slice<C: Signing>(
    secp: &Secp256k1<C>,
    data: &[u8]
) -> Result<KeyPair, Error>

Creates a KeyPair directly from a secret key slice.

Errors

Error::InvalidSecretKey if the provided data has an incorrect length, exceeds Secp256k1 field p value or the corresponding public key is not even.

pub fn from_seckey_str<C: Signing>(
    secp: &Secp256k1<C>,
    s: &str
) -> Result<KeyPair, Error>

Creates a KeyPair directly from a secret key string.

Errors

Error::InvalidSecretKey if corresponding public key for the provided secret key is not even.

pub fn from_seckey_str_global(s: &str) -> Result<KeyPair, Error>

Creates a KeyPair directly from a secret key string and the global SECP256K1 context.

Errors

Error::InvalidSecretKey if corresponding public key for the provided secret key is not even.

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

Returns the secret bytes for this key pair.

pub fn tweak_add_assign<C: Verification>(
    &mut self,
    secp: &Secp256k1<C>,
    tweak: &Scalar
) -> Result<(), Error>

👎Deprecated since 0.23.0: Use add_xonly_tweak instead

Tweaks a keypair by adding the given tweak to the secret key and updating the public key accordingly.

pub fn add_xonly_tweak<C: Verification>(
    self,
    secp: &Secp256k1<C>,
    tweak: &Scalar
) -> Result<KeyPair, Error>

Tweaks a keypair by first converting the public key to an xonly key and tweaking it.

Errors

Returns an error if the resulting key would be invalid.

NB: Will not error if the tweaked public key has an odd value and can’t be used for BIP 340-342 purposes.

Examples

use secp256k1::{Secp256k1, KeyPair, Scalar};
use secp256k1::rand::{RngCore, thread_rng};

let secp = Secp256k1::new();
let tweak = Scalar::random();

let mut key_pair = KeyPair::new(&secp, &mut thread_rng());
let tweaked = key_pair.add_xonly_tweak(&secp, &tweak).expect("Improbable to fail with a randomly generated tweak");

pub fn secret_key(&self) -> SecretKey

Returns the SecretKey for this KeyPair.

This is equivalent to using SecretKey::from_keypair.

pub fn public_key(&self) -> PublicKey

Returns the PublicKey for this KeyPair.

This is equivalent to using PublicKey::from_keypair.

pub fn x_only_public_key(&self) -> (XOnlyPublicKey, Parity)

Returns the XOnlyPublicKey (and it’s Parity) for this KeyPair.

This is equivalent to using XOnlyPublicKey::from_keypair.

Trait Implementations

impl Clone for KeyPair

fn clone(&self) -> KeyPair

Returns a copy 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<'a> From<&'a KeyPair> for PublicKey

fn from(pair: &'a KeyPair) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyPair> for SecretKey

fn from(pair: &'a KeyPair) -> Self

Converts to this type from the input type.

impl From<KeyPair> for PublicKey

fn from(pair: KeyPair) -> Self

Converts to this type from the input type.

impl From<KeyPair> for SecretKey

fn from(pair: KeyPair) -> Self

Converts to this type from the input type.

impl FromStr for KeyPair

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for KeyPair

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for KeyPair

fn cmp(&self, other: &KeyPair) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<KeyPair> for KeyPair

fn eq(&self, other: &KeyPair) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<KeyPair> for KeyPair

fn partial_cmp(&self, other: &KeyPair) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for KeyPair

impl Eq for KeyPair

impl StructuralEq for KeyPair

impl StructuralPartialEq for KeyPair