pub struct KeyPair(_);
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 u8
s 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
sourceimpl KeyPair
impl KeyPair
sourcepub fn display_secret(&self) -> DisplaySecret
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())
);
sourceimpl KeyPair
impl KeyPair
sourcepub fn as_ptr(&self) -> *const KeyPair
pub fn as_ptr(&self) -> *const KeyPair
Obtains a raw const pointer suitable for use with FFI functions.
sourcepub fn as_mut_ptr(&mut self) -> *mut KeyPair
pub fn as_mut_ptr(&mut self) -> *mut KeyPair
Obtains a raw mutable pointer suitable for use with FFI functions.
sourcepub fn from_secret_key<C>(secp: &Secp256k1<C>, sk: &SecretKey) -> KeyPair where
C: Signing,
pub fn from_secret_key<C>(secp: &Secp256k1<C>, sk: &SecretKey) -> KeyPair where
C: Signing,
Creates a KeyPair
directly from a Secp256k1 secret key.
sourcepub fn from_seckey_slice<C>(
secp: &Secp256k1<C>,
data: &[u8]
) -> Result<KeyPair, Error> where
C: Signing,
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.
sourcepub fn from_seckey_str<C>(secp: &Secp256k1<C>, s: &str) -> Result<KeyPair, Error> where
C: Signing,
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.
sourcepub fn new<R, C>(secp: &Secp256k1<C>, rng: &mut R) -> KeyPair where
R: Rng + ?Sized,
C: Signing,
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());
sourcepub fn secret_bytes(&self) -> [u8; 32]
pub fn secret_bytes(&self) -> [u8; 32]
Returns the secret bytes for this key pair.
sourcepub 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
pub fn tweak_add_assign<C>(
&mut self,
secp: &Secp256k1<C>,
tweak: &Scalar
) -> Result<(), Error> where
C: Verification,
Use add_xonly_tweak instead
Tweaks a keypair by adding the given tweak to the secret key and updating the public key accordingly.
sourcepub fn add_xonly_tweak<C>(
self,
secp: &Secp256k1<C>,
tweak: &Scalar
) -> Result<KeyPair, Error> where
C: Verification,
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");
sourcepub fn secret_key(&self) -> SecretKey
pub fn secret_key(&self) -> SecretKey
Returns the SecretKey
for this KeyPair
.
This is equivalent to using SecretKey::from_keypair
.
sourcepub fn public_key(&self) -> PublicKey
pub fn public_key(&self) -> PublicKey
Returns the PublicKey
for this KeyPair
.
This is equivalent to using PublicKey::from_keypair
.
sourcepub fn x_only_public_key(&self) -> (XOnlyPublicKey, Parity)
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
sourceimpl<'de> Deserialize<'de> for KeyPair
impl<'de> Deserialize<'de> for KeyPair
sourcefn deserialize<D>(d: D) -> Result<KeyPair, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
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
sourceimpl From<TweakedKeyPair> for KeyPair
impl From<TweakedKeyPair> for KeyPair
sourcefn from(pair: TweakedKeyPair) -> Self
fn from(pair: TweakedKeyPair) -> Self
Converts to this type from the input type.
sourceimpl Ord for KeyPair
impl Ord for KeyPair
1.21.0 · sourcefn max(self, other: Self) -> Self
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
1.21.0 · sourcefn min(self, other: Self) -> Self
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
Restrict a value to a certain interval. Read more
sourceimpl PartialOrd<KeyPair> for KeyPair
impl PartialOrd<KeyPair> for KeyPair
sourcefn partial_cmp(&self, other: &KeyPair) -> Option<Ordering>
fn partial_cmp(&self, other: &KeyPair) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl Serialize for KeyPair
impl Serialize for KeyPair
sourcefn serialize<S>(
&self,
s: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
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. Read more
impl Copy for KeyPair
impl Eq for KeyPair
impl StructuralEq for KeyPair
impl StructuralPartialEq for KeyPair
Auto Trait Implementations
impl RefUnwindSafe for KeyPair
impl Send for KeyPair
impl Sync for KeyPair
impl Unpin for KeyPair
impl UnwindSafe for KeyPair
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more