Struct SecretKeyRef

pub struct SecretKeyRef<'a> { /* private fields */ }

A SecretKey reference wrapper.

A wrapper around secp256k1::SecretKey reference, which enables it to be used in methods expecting Key capabilities.

Implementations

impl<'a> SecretKeyRef<'a>

pub fn new(key: &'a SecretKey) -> Self

A simple wrapper around a reference to SecretKey which allows it to be usable for signing.

Methods from Deref<Target = SecretKey>

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 caution.

Examples

use secp256k1::SecretKey;
let key = SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000001").unwrap();

// Normal debug hides value (`Display` is not implemented for `SecretKey`).
// E.g., `format!("{:?}", key)` prints "SecretKey(#2518682f7819fb2d)".

// 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())
);

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

Returns the secret key as a byte value.

pub fn keypair<C>(&self, secp: &Secp256k1<C>) -> KeyPair

where C: Signing,

Returns the KeyPair for this SecretKey.

This is equivalent to using KeyPair::from_secret_key.

pub fn public_key<C>(&self, secp: &Secp256k1<C>) -> PublicKey

where C: Signing,

Returns the PublicKey for this SecretKey.

This is equivalent to using PublicKey::from_secret_key.

pub fn x_only_public_key<C>( &self, secp: &Secp256k1<C>, ) -> (XOnlyPublicKey, Parity)

where C: Signing,

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

This is equivalent to XOnlyPublicKey::from_keypair(self.keypair(secp)).

Trait Implementations

impl<'a> Deref for SecretKeyRef<'a>

type Target = SecretKey

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

fn from(key: &'a SecretKey) -> Self

Converts to this type from the input type.