Struct secp256k1::SecretKey

pub struct SecretKey(_);

Secret 256-bit key used as x in an ECDSA signature.

Serde support

Implements de/serialization with the serde feature enabled. 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).

Examples

Basic usage:

use secp256k1::{rand, Secp256k1, SecretKey};

let secp = Secp256k1::new();
let secret_key = SecretKey::new(&mut rand::thread_rng());

Implementations

impl 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

let key = secp256k1::ONE_KEY;

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

impl SecretKey

pub fn as_ptr(&self) -> *const u8

Converts the object to a raw pointer for FFI interfacing

pub fn as_mut_ptr(&mut self) -> *mut u8

Converts the object to a mutable raw pointer for FFI interfacing

pub fn len(&self) -> usize

Returns the length of the object as an array

pub fn is_empty(&self) -> bool

Returns whether the object as an array is empty

impl SecretKey

pub fn from_slice(data: &[u8]) -> Result<SecretKey, Error>

Converts a SECRET_KEY_SIZE-byte slice to a secret key.

Examples

use secp256k1::SecretKey;
let sk = SecretKey::from_slice(&[0xcd; 32]).expect("32 bytes, within curve order");

pub fn from_keypair(keypair: &KeyPair) -> Self

Creates a new secret key using data from BIP-340 KeyPair.

Examples

use secp256k1::{rand, Secp256k1, SecretKey, KeyPair};

let secp = Secp256k1::new();
let key_pair = KeyPair::new(&secp, &mut rand::thread_rng());
let secret_key = SecretKey::from_keypair(&key_pair);

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

Returns the secret key as a byte value.

pub fn negate_assign(&mut self)

👎Deprecated since 0.23.0: Use negate instead

Negates the secret key.

pub fn negate(self) -> SecretKey

Negates the secret key.

pub fn add_assign(&mut self, other: &Scalar) -> Result<(), Error>

👎Deprecated since 0.23.0: Use add_tweak instead

Adds one secret key to another, modulo the curve order.

Errors

Returns an error if the resulting key would be invalid.

pub fn add_tweak(self, tweak: &Scalar) -> Result<SecretKey, Error>

Tweaks a SecretKey by adding tweak modulo the curve order.

Errors

Returns an error if the resulting key would be invalid.

pub fn mul_assign(&mut self, other: &Scalar) -> Result<(), Error>

👎Deprecated since 0.23.0: Use mul_tweak instead

Multiplies one secret key by another, modulo the curve order. Will return an error if the resulting key would be invalid.

pub fn mul_tweak(self, tweak: &Scalar) -> Result<SecretKey, Error>

Tweaks a SecretKey by multiplying by tweak modulo the curve order.

Errors

Returns an error if the resulting key would be invalid.

pub fn sign_ecdsa(&self, msg: Message) -> Signature

Constructs an ECDSA signature for msg using the global SECP256K1 context.

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

Returns the KeyPair for this SecretKey.

This is equivalent to using KeyPair::from_secret_key.

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

Returns the PublicKey for this SecretKey.

This is equivalent to using PublicKey::from_secret_key.

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

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

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

Trait Implementations

impl AsRef<[u8; 32]> for SecretKey

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

Gets a reference to the underlying array

impl CPtr for SecretKey

type Target = u8

fn as_c_ptr(&self) -> *const Self::Target

fn as_mut_c_ptr(&mut self) -> *mut Self::Target

impl Clone for SecretKey

fn clone(&self) -> SecretKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SecretKey

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl From<KeyPair> for SecretKey

fn from(pair: KeyPair) -> Self

Converts to this type from the input type.

impl From<SecretKey> for Scalar

fn from(value: SecretKey) -> Self

Converts to this type from the input type.

impl FromStr for SecretKey

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<SecretKey, Error>

Parses a string s to return a value of this type.

impl Hash for SecretKey

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<Range<usize>> for SecretKey

type Output = [u8]

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &[u8]

Performs the indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for SecretKey

type Output = [u8]

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &[u8]

Performs the indexing (container[index]) operation.

impl Index<RangeFull> for SecretKey

type Output = [u8]

The returned type after indexing.

fn index(&self, _: RangeFull) -> &[u8]

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for SecretKey

type Output = [u8]

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &[u8]

Performs the indexing (container[index]) operation.

impl Index<usize> for SecretKey

type Output = u8

The returned type after indexing.

fn index(&self, index: usize) -> &u8

Performs the indexing (container[index]) operation.

impl Ord for SecretKey

fn cmp(&self, other: &SecretKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<SecretKey> for SecretKey

fn eq(&self, other: &SecretKey) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<SecretKey> for SecretKey

fn partial_cmp(&self, other: &SecretKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for SecretKey

impl Eq for SecretKey