Struct secp256k1::KeyPair

pub struct KeyPair(_);

Opaque data structure that holds a keypair consisting of a secret and a public 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);

// Normal display hides value
assert_eq!(
    "KeyPair(#2518682f7819fb2d)",
    format!("{:?}", key)
);
// Here we explicitly display the secret value:
assert_eq!(
    "0000000000000000000000000000000000000000000000000000000000000001",
    format!("{}", key.display_secret())
);
assert_eq!(
    "DisplaySecret(\"0000000000000000000000000000000000000000000000000000000000000001\")",
    format!("{:?}", 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 Schnorr KeyPair directly from generic Secp256k1 secret key

Panic

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: Signing>(
    secp: &Secp256k1<C>,
    data: &[u8]
) -> Result<KeyPair, Error>

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

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: Rng + ?Sized, C: Signing>(
    secp: &Secp256k1<C>,
    rng: &mut R
) -> KeyPair

This is supported on crate feature rand only.

Generates a new random secret key.

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

Serialize the key pair as a secret key byte value

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

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

Will return 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.

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

This is supported on crate feature std only.

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

Formats the value using the given formatter.

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

This is supported on crate feature serde only.

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

Deserialize this value from the given Serde deserializer.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl From<KeyPair> for SecretKey

fn from(pair: KeyPair) -> Self

Performs the conversion.

impl From<KeyPair> for PublicKey

fn from(pair: KeyPair) -> Self

Performs the conversion.

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

This is supported on crate feature serde only.

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

Serialize this value into the given Serde serializer.