Struct fedimint_core::core::KeyPair

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

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) -> KeyPairwhere 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 from_seckey_str_global(s: &str) -> Result<KeyPair, Error>

Creates a KeyPair directly from a secret key string and the global [SECP256K1] context.

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) -> KeyPairwhere 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 new_global<R>(rng: &mut R) -> KeyPairwhere R: Rng + ?Sized,

Generates a new random secret key using the global [SECP256K1] context.

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

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

Constructs an schnorr signature for msg using the global [SECP256K1] context.

Trait Implementations

impl Clone for KeyPair

fn clone(&self) -> KeyPair

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyPair

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

Formats the value using the given formatter.

impl Decodable for KeyPair

fn consensus_decode<D: Read>( d: &mut D, modules: &ModuleDecoderRegistry ) -> Result<Self, DecodeError>

Decode an object with a well-defined format

fn consensus_decode_hex( hex: &str, modules: &ModuleDecoderRegistry ) -> Result<Self, DecodeError>

Decode an object from hex

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.

impl Encodable for KeyPair

fn consensus_encode<W: Write>(&self, writer: &mut W) -> Result<usize, Error>

Encode an object with a well-defined format. Returns the number of bytes written on success.

fn consensus_encode_to_vec(&self) -> Result<Vec<u8>, Error>

Self::consensus_encode to newly allocated Vec<u8>

fn consensus_encode_to_hex(&self) -> Result<String, Error>

fn consensus_hash<H>(&self) -> Hwhere H: Hash, H::Engine: Write,

Generate a SHA256 hash of the consensus encoding using the default hash engine for H.

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

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

Converts to this type from the input type.

impl From<KeyPair> for PublicKey

fn from(pair: KeyPair) -> PublicKey

Converts to this type from the input type.

impl From<TweakedKeyPair> for KeyPair

fn from(pair: TweakedKeyPair) -> KeyPair

Converts to this type from the input type.

impl FromStr for KeyPair

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<KeyPair, <KeyPair as FromStr>::Err>

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

impl Hash for KeyPair

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

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 Ord for KeyPair

fn cmp(&self, other: &KeyPair) -> 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,

Restrict a value to a certain interval.

impl PartialEq for KeyPair

fn eq(&self, other: &KeyPair) -> 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 for KeyPair

fn partial_cmp(&self, other: &KeyPair) -> 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 Serialize for KeyPair

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.

impl TapTweak for KeyPair

fn tap_tweak<C>( self, secp: &Secp256k1<C>, merkle_root: Option<TapBranchHash> ) -> TweakedKeyPairwhere C: Verification,

Tweaks private and public keys within an untweaked KeyPair with corresponding public key value and optional script tree merkle root.

This is done by tweaking private key within the pair using the equation q = p + H(P|c), where

• q is the tweaked private key
• p is the internal private key
• H is the hash function
• c is the commitment data The public key is generated from a private key by multiplying with generator point, Q = qG.

Returns

The tweaked key and its parity.

type TweakedAux = TweakedKeyPair

Tweaked key type with optional auxiliary information

type TweakedKey = TweakedKeyPair

Tweaked key type

fn dangerous_assume_tweaked(self) -> TweakedKeyPair

Directly converts an UntweakedPublicKey to a TweakedPublicKey

impl Copy for KeyPair

impl Eq for KeyPair

impl StructuralEq for KeyPair

impl StructuralPartialEq for KeyPair