Struct secp256k1::PublicKey

source · [−]

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

Expand description

A Secp256k1 public key, used for verification of signatures.

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

source

impl PublicKey

source

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

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

source

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

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

source

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

source

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

This is supported on crate feature global-context only.

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

source

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

Creates a public key directly from a slice.

source

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

source

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.

source

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

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

source

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

Negates the public key in place.

source

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

Adds the other public key to self in place.

Errors

Returns an error if the resulting key would be invalid or if the tweak was not a 32-byte length slice.

source

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

Muliplies the public key in place by the scalar other.

Errors

Returns an error if the resulting key would be invalid or if the tweak was not a 32-byte length slice.

source

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");

source

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");