Struct secp256k1::PublicKey

#[repr(transparent)]
pub struct PublicKey(_);

A Secp256k1 public key, used for verification of signatures.

Serde support

Implements de/serialization with the serde feature enabled. We treat the byte value as a tuple of 33 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::{SecretKey, Secp256k1, PublicKey};

let secp = Secp256k1::new();
let secret_key = SecretKey::from_slice(&[0xcd; 32]).expect("32 bytes, within curve order");
let public_key = PublicKey::from_secret_key(&secp, &secret_key);

Implementations

impl PublicKey

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

Obtains a raw const pointer suitable for use with FFI functions.

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

Obtains a raw mutable pointer suitable for use with FFI functions.

pub fn from_secret_key<C: Signing>(
    secp: &Secp256k1<C>,
    sk: &SecretKey
) -> PublicKey

Creates a new public key from a SecretKey.

Examples

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

let secp = Secp256k1::new();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let public_key = PublicKey::from_secret_key(&secp, &secret_key);

pub fn from_secret_key_global(sk: &SecretKey) -> PublicKey

Creates a new public key from a SecretKey and the global SECP256K1 context.

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

Creates a public key directly from a slice.

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

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

Examples

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

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

pub fn from_x_only_public_key(pk: XOnlyPublicKey, parity: Parity) -> PublicKey

Creates a PublicKey using the key material from pk combined with the parity.

pub fn serialize(&self) -> [u8; 33]

Serializes the key as a byte-encoded pair of values. In compressed form the y-coordinate is represented by only a single bit, as x determines it up to one bit.

pub fn serialize_uncompressed(&self) -> [u8; 65]

Serializes the key as a byte-encoded pair of values, in uncompressed form.

pub fn negate_assign<C: Verification>(&mut self, secp: &Secp256k1<C>)

👎Deprecated since 0.23.0: Use negate instead

Negates the public key in place.

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

Negates the public key.

pub fn add_exp_assign<C: Verification>(
    &mut self,
    secp: &Secp256k1<C>,
    other: &Scalar
) -> Result<(), Error>

👎Deprecated since 0.23.0: Use add_exp_tweak instead

Adds other * G to self in place.

Errors

Returns an error if the resulting key would be invalid.

pub fn add_exp_tweak<C: Verification>(
    self,
    secp: &Secp256k1<C>,
    tweak: &Scalar
) -> Result<PublicKey, Error>

Tweaks a PublicKey by adding tweak * G modulo the curve order.

Errors

Returns an error if the resulting key would be invalid.

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

👎Deprecated since 0.23.0: Use mul_tweak instead

Muliplies the public key in place by the scalar other.

Errors

Returns an error if the resulting key would be invalid.

pub fn mul_tweak<C: Verification>(
    self,
    secp: &Secp256k1<C>,
    other: &Scalar
) -> Result<PublicKey, Error>

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

Errors

Returns an error if the resulting key would be invalid.

pub fn combine(&self, other: &PublicKey) -> Result<PublicKey, Error>

Adds a second key to this one, returning the sum.

Errors

If the result would be the point at infinity, i.e. adding this point to its own negation.

Examples

use secp256k1::{rand, Secp256k1};

let secp = Secp256k1::new();
let mut rng = rand::thread_rng();
let (_, pk1) = secp.generate_keypair(&mut rng);
let (_, pk2) = secp.generate_keypair(&mut rng);
let sum = pk1.combine(&pk2).expect("It's improbable to fail for 2 random public keys");

pub fn combine_keys(keys: &[&PublicKey]) -> Result<PublicKey, Error>

Adds the keys in the provided slice together, returning the sum.

Errors

Errors under any of the following conditions:

• The result would be the point at infinity, i.e. adding a point to its own negation.
• The provided slice is empty.
• The number of elements in the provided slice is greater than i32::MAX.

Examples

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

let secp = Secp256k1::new();
let mut rng = rand::thread_rng();
let (_, pk1) = secp.generate_keypair(&mut rng);
let (_, pk2) = secp.generate_keypair(&mut rng);
let (_, pk3) = secp.generate_keypair(&mut rng);
let sum = PublicKey::combine_keys(&[&pk1, &pk2, &pk3]).expect("It's improbable to fail for 3 random public keys");

pub fn x_only_public_key(&self) -> (XOnlyPublicKey, Parity)

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

Trait Implementations

impl CPtr for PublicKey

type Target = PublicKey

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

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

impl Clone for PublicKey

fn clone(&self) -> PublicKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PublicKey

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

Formats the value using the given formatter.

impl Display for PublicKey

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl From<KeyPair> for PublicKey

fn from(pair: KeyPair) -> Self

Converts to this type from the input type.

impl From<PublicKey> for PublicKey

Creates a new public key from a FFI public key

fn from(pk: PublicKey) -> PublicKey

Converts to this type from the input type.

impl From<PublicKey> for XOnlyPublicKey

fn from(src: PublicKey) -> XOnlyPublicKey

Converts to this type from the input type.

impl FromStr for PublicKey

type Err = Error

The associated error which can be returned from parsing.

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

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

impl Hash for PublicKey

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 LowerHex for PublicKey

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

Formats the value using the given formatter.

impl Ord for PublicKey

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

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

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

impl Eq for PublicKey

impl StructuralEq for PublicKey

impl StructuralPartialEq for PublicKey