Struct ECPrivateKey 

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

A private key for elliptic curve digital signature algorithms.

An ECPrivateKey is a 32-byte secret value that can be used to:

• Generate its corresponding public key
• Sign messages using the ECDSA signature scheme
• Sign messages using the Schnorr signature scheme (BIP-340)

These keys use the secp256k1 curve, which is the same curve used in Bitcoin and other cryptocurrencies. The secp256k1 curve is defined by the Standards for Efficient Cryptography Group (SECG).

Security

Private keys should be kept secret and never exposed. They represent proof of ownership and control over any associated assets or identities.

Examples

Creating a new random private key:

use bc_components::ECPrivateKey;

// Generate a random private key
let private_key = ECPrivateKey::new();

Signing a message with ECDSA:

use bc_components::ECPrivateKey;

// Generate a random private key
let private_key = ECPrivateKey::new();

// Sign a message
let message = b"Hello, world!";
let signature = private_key.ecdsa_sign(message);

Implementations

impl ECPrivateKey

pub fn new() -> Self

Creates a new random ECDSA private key.

Uses a secure random number generator to generate the key.

pub fn new_using(rng: &mut impl RandomNumberGenerator) -> Self

Creates a new random ECDSA private key using the given random number generator.

This allows for deterministic key generation when using a seeded RNG.

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

Returns the ECDSA private key as an array of bytes.

pub fn as_bytes(&self) -> &[u8]

Get the ECDSA private key as a byte slice.

pub const fn from_data(data: [u8; 32]) -> Self

Restores an ECDSA private key from an array of bytes.

This method performs no validation on the input data.

pub fn from_data_ref(data: impl AsRef<[u8]>) -> Result<Self>

Restores an ECDSA private key from a reference to an array of bytes.

Returns an error if the data is not exactly 32 bytes.

pub fn derive_from_key_material(key_material: impl AsRef<[u8]>) -> Self

Derives a new private key from the given key material.

This method uses the provided key material to deterministically generate a valid private key for the secp256k1 curve.

impl ECPrivateKey

pub fn schnorr_public_key(&self) -> SchnorrPublicKey

Derives the Schnorr public key from this ECDSA private key.

Schnorr public keys are used with the BIP-340 Schnorr signature scheme. Unlike ECDSA public keys, Schnorr public keys are 32 bytes (“x-only”) rather than 33 bytes.

pub fn ecdsa_sign(&self, message: impl AsRef<[u8]>) -> [u8; 64]

Signs a message using the ECDSA signature scheme.

Returns a 70-72 byte signature in DER format.

pub fn schnorr_sign_using( &self, message: impl AsRef<[u8]>, rng: &mut dyn RandomNumberGenerator, ) -> [u8; 64]

Signs a message using the Schnorr signature scheme with a custom random number generator.

This method implements the BIP-340 Schnorr signature scheme, which provides several advantages over ECDSA including linearity (allowing for signature aggregation) and non-malleability.

Returns a 64-byte signature.

pub fn schnorr_sign(&self, message: impl AsRef<[u8]>) -> [u8; 64]

Signs a message using the Schnorr signature scheme.

Uses a secure random number generator for nonce generation.

Returns a 64-byte signature.

Trait Implementations

impl AsRef<[u8]> for ECPrivateKey

Provides a reference to the key data as a byte slice.

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

Returns a reference to the key as a byte slice.

impl CBORTagged for ECPrivateKey

Defines CBOR tags for EC keys.

fn cbor_tags() -> Vec<Tag>

Returns the CBOR tags for EC keys.

impl CBORTaggedEncodable for ECPrivateKey

Implements CBOR encoding for EC private keys.

fn untagged_cbor(&self) -> CBOR

Creates the untagged CBOR representation.

The format is a map with:

• Key 2: boolean true (indicates private key)
• Key 3: byte string of the key data

fn tagged_cbor(&self) -> CBOR

Returns the tagged CBOR encoding of this instance.

fn tagged_cbor_data(&self) -> Vec<u8>

Returns the tagged value in CBOR binary representation.

impl Clone for ECPrivateKey

fn clone(&self) -> ECPrivateKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ECPrivateKey

Formats the key for debugging, showing type name and hexadecimal value.

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

Displays the key with type information and hexadecimal value.

impl Default for ECPrivateKey

Implements the Default trait, creating a random key.

fn default() -> Self

Creates a new random key as the default value.

impl Display for ECPrivateKey

Formats the key as a hexadecimal string.

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

Displays the key as a hexadecimal string.

impl ECKey for ECPrivateKey

Implements the ECKey trait for deriving public keys.

fn public_key(&self) -> ECPublicKey

Derives the corresponding ECDSA compressed public key.

impl ECKeyBase for ECPrivateKey

Implements the ECKeyBase trait methods.

const KEY_SIZE: usize = 32usize

The size of an EC private key (32 bytes).

fn from_data_ref(data: impl AsRef<[u8]>) -> Result<Self>

where Self: Sized,

Creates a key from a byte slice, with validation.

fn data(&self) -> &[u8]

Returns the key as a byte slice.

fn hex(&self) -> String

Returns the key as a hexadecimal string.

fn from_hex(hex: impl AsRef<str>) -> Result<Self>

Creates a key from a hexadecimal string.

impl<'a> From<&'a ECPrivateKey> for &'a [u8]

Converts a reference to an ECPrivateKey to a reference to a byte slice.

fn from(value: &'a ECPrivateKey) -> Self

Returns a reference to the key as a byte slice.

impl<'a> From<&'a ECPrivateKey> for &'a [u8; 32]

Converts a reference to an ECPrivateKey to a reference to a fixed-size byte array.

fn from(value: &'a ECPrivateKey) -> Self

Returns a reference to the underlying byte array.

impl From<[u8; 32]> for ECPrivateKey

Converts a fixed-size byte array to an ECPrivateKey.

fn from(data: [u8; 32]) -> Self

Converts a 32-byte array into an EC private key.

impl From<ECPrivateKey> for CBOR

Converts an ECPrivateKey to CBOR.

fn from(value: ECPrivateKey) -> Self

Converts to tagged CBOR.

impl Hash for ECPrivateKey

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 PartialEq for ECPrivateKey

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for ECPrivateKey

impl StructuralPartialEq for ECPrivateKey