Struct breez_sdk_core::bitcoin::util::key::KeyPair

pub struct KeyPair(/* private fields */);

Expand description

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

Creates a KeyPair directly from a Secp256k1 secret key.

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

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

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 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: &Scalar, ) -> Result<(), Error>
where C: Verification,

👎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>( self, secp: &Secp256k1<C>, tweak: &Scalar, ) -> Result<KeyPair, Error>
where C: Verification,

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. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

§

impl Debug for KeyPair

§

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

Formats the value using the given formatter. Read more

§

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. Read more

§