Struct SchnorrPublicKey 

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

A Schnorr (x-only) elliptic curve public key.

A SchnorrPublicKey is a 32-byte “x-only” public key used with the BIP-340 Schnorr signature scheme. Unlike compressed ECDSA public keys (33 bytes) that include a prefix byte indicating the parity of the y-coordinate, Schnorr public keys only contain the x-coordinate of the elliptic curve point.

Schnorr signatures offer several advantages over traditional ECDSA signatures:

• Linearity: Enables key and signature aggregation (eg., for multisignature schemes)
• Non-malleability: Prevents third parties from modifying signatures
• Smaller size: Signatures are 64 bytes vs 70-72 bytes for ECDSA
• Better privacy: Makes different multisig policies indistinguishable
• Provable security: Requires fewer cryptographic assumptions than ECDSA

Schnorr signatures were introduced to Bitcoin via the Taproot upgrade (BIP-340) and are becoming more widely used in cryptocurrency applications.

Examples

Verifying a Schnorr signature:

use bc_components::ECPrivateKey;

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

// Get the Schnorr public key
let schnorr_public_key = private_key.schnorr_public_key();

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

// Verify the signature
assert!(schnorr_public_key.schnorr_verify(&signature, message));

Implementations

impl SchnorrPublicKey

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

Restores a Schnorr public key from an array of bytes.

This method performs no validation on the input data.

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

Returns the Schnorr public key as an array of bytes.

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

Get the Schnorr public key as a byte slice.

impl SchnorrPublicKey

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

Verifies a Schnorr signature for a message using this public key.

Returns true if the signature is valid for the given message and this public key, and false otherwise.

This implementation follows the BIP-340 Schnorr signature verification algorithm.

Parameters

• signature: A 64-byte Schnorr signature
• message: The message that was signed

Trait Implementations

impl AsRef<[u8]> for SchnorrPublicKey

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 Clone for SchnorrPublicKey

fn clone(&self) -> SchnorrPublicKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SchnorrPublicKey

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 Display for SchnorrPublicKey

Formats the key as a hexadecimal string.

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

Displays the key as a hexadecimal string.

impl ECKeyBase for SchnorrPublicKey

Implements the ECKeyBase trait methods for SchnorrPublicKey.

const KEY_SIZE: usize = 32usize

The size of a Schnorr public 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 SchnorrPublicKey> for &'a [u8; 32]

Converts a reference to a SchnorrPublicKey to a reference to a fixed-size byte array.

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

Returns a reference to the underlying byte array.

impl From<[u8; 32]> for SchnorrPublicKey

Converts a fixed-size byte array to a SchnorrPublicKey.

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

Converts a 32-byte array into a Schnorr public key.

impl Hash for SchnorrPublicKey

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 SchnorrPublicKey

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

impl StructuralPartialEq for SchnorrPublicKey