Struct bitcoin::KeyPair

pub struct KeyPair(_);

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

Serde support

Serialize and Deserialize are not implemented for this type, even with the serde feature active. This is due to security considerations, see the [serde_keypair] documentation for details.

If the serde and global-context features are active KeyPairs can be serialized and deserialized by annotating them with #[serde(with = "secp256k1::serde_keypair")] inside structs or enums for which Serialize and Deserialize are being derived.

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>(secp: &Secp256k1<C>, sk: SecretKey) -> KeyPair where
    C: Signing, 

Creates a Schnorr KeyPair directly from generic Secp256k1 secret key.

Panics

Panics if internal representation of the provided SecretKey does not hold correct secret key value obtained from Secp256k1 library previously, specifically when secret key value is out-of-range (0 or in excess of the group order).

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

Creates a Schnorr 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>(
    secp: &Secp256k1<C>,
    s: &str
) -> Result<KeyPair, Error> where
    C: Signing, 

Creates a Schnorr KeyPair directly from a secret key string.

Errors

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

pub fn new<R, C>(secp: &Secp256k1<C>, rng: &mut R) -> KeyPair where
    R: Rng + ?Sized,
    C: Signing, 

Generates a new random secret key.

Examples

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

let secp = Secp256k1::new();
let key_pair = KeyPair::new(&secp, &mut rand::thread_rng());

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

Returns the secret bytes for this key pair.

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

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

Errors

Returns an error if the resulting key would be invalid or if the tweak was not a 32-byte length slice.

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};
use secp256k1::rand::{RngCore, thread_rng};

let secp = Secp256k1::new();
let mut tweak = [0u8; 32];
thread_rng().fill_bytes(&mut tweak);

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

pub fn public_key(&self) -> XOnlyPublicKey

Gets the XOnlyPublicKey for this 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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyPair

fn deserialize<D>(d: D) -> Result<KeyPair, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<TweakedKeyPair> for KeyPair

fn from(pair: TweakedKeyPair) -> 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<KeyPair, <KeyPair as FromStr>::Err>

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

impl Hash for KeyPair

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

Feeds this value into the given Hasher.

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

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> 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: &KeyPair) -> bool

This method tests for !=.

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 Serialize for KeyPair

fn serialize<S>(
    &self,
    s: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl Copy for KeyPair

impl Eq for KeyPair

impl StructuralEq for KeyPair

impl StructuralPartialEq for KeyPair