Struct PrivateKey 

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

A secret key used for signing and hashing.

This type has a safe Debug implementation that does not leak information. Additionally, it implements Drop to zeroize the memory to make leaking passwords less likely.

Implementations

impl PrivateKey

pub fn from_raw(raw: [u8; 32]) -> Result<Self, InvalidPrivateKey>

Creates a new private key from raw bytes.

pub fn from_slice<B: AsRef<[u8]>>(raw: B) -> Result<Self, InvalidPrivateKey>

Creates a new private key from a slice of bytes.

pub fn from_hex_str<S: AsRef<str>>(s: S) -> Result<Self, InvalidPrivateKey>

Creates a new private key from a hex string representation. Accepts hex string with or without leading "0x".

pub fn public_address(&self) -> Address

Gets the public address for a given private key.

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 Clone for PrivateKey

fn clone(&self) -> PrivateKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateKey

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

Formats the value using the given formatter.

impl Deref for PrivateKey

type Target = SecretKey

The resulting type after dereferencing.

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

Dereferences the value.

impl FromStr for PrivateKey

type Err = InvalidPrivateKey

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 Key for &PrivateKey

fn sign( &self, message: &[u8], chain_id: Option<u64>, ) -> Result<Signature, SigningError>

Sign given message and include chain-id replay protection.

fn sign_message(&self, message: &[u8]) -> Result<Signature, SigningError>

Sign given message without manipulating V-value; used for typed transactions (AccessList and EIP-1559)

fn address(&self) -> Address

Get public address that this key represents.