Struct ECPublicKey 

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

A compressed elliptic curve digital signature algorithm (ECDSA) public key.

An ECPublicKey is a 33-byte compressed representation of a public key on the secp256k1 curve. The first byte is a prefix (0x02 or 0x03) that indicates the parity of the y-coordinate, followed by the 32-byte x-coordinate.

These public keys are used to:

• Verify ECDSA signatures
• Identify the owner of a private key without revealing the private key
• Derive shared secrets (when combined with another party’s private key)

Unlike the larger 65-byte uncompressed format (ECUncompressedPublicKey), compressed public keys save space while providing the same cryptographic security.

Examples

Verifying an ECDSA signature:

use bc_components::{ECKey, ECPrivateKey, ECPublicKey};

// Generate a keypair
let private_key = ECPrivateKey::new();
let public_key = private_key.public_key();

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

// Verify the signature
assert!(public_key.verify(&signature, message));

Implementations

impl ECPublicKey

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

Restores an ECDSA public key from an array of bytes.

This method performs no validation on the input data.

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

Returns the ECDSA public key as an array of bytes.

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

Get the ECDSA public key as a byte slice.

impl ECPublicKey

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

Verifies an ECDSA 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.

Parameters

• signature: A 70-72 byte DER-encoded ECDSA signature
• message: The message that was signed

Trait Implementations

impl AsRef<[u8]> for ECPublicKey

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

Converts this type into a shared reference of the (usually inferred) input type.

impl CBORTagged for ECPublicKey

Defines CBOR tags for EC keys.

fn cbor_tags() -> Vec<Tag>

Returns the CBOR tags for EC keys.

impl CBORTaggedEncodable for ECPublicKey

Implements CBOR encoding for EC public keys.

fn untagged_cbor(&self) -> CBOR

Creates the untagged CBOR representation.

The format is a map with:

• Key 3: byte string of the key data (Note the absence of key 2, which would indicate a private key)

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 ECPublicKey

fn clone(&self) -> ECPublicKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ECPublicKey

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 ECPublicKey

Formats the key as a hexadecimal string.

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

Displays the key as a hexadecimal string.

impl ECKey for ECPublicKey

Implements the ECKey trait for ECPublicKey.

fn public_key(&self) -> ECPublicKey

Returns the public key (self).

impl ECKeyBase for ECPublicKey

Implements the ECKeyBase trait methods for ECPublicKey.

const KEY_SIZE: usize = 33usize

The size of an EC compressed public key (33 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 ECPublicKeyBase for ECPublicKey

Implements the ECPublicKeyBase trait for converting to uncompressed format.

fn uncompressed_public_key(&self) -> ECUncompressedPublicKey

Converts this compressed public key to its uncompressed form.

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

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

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

Returns a reference to the key as a byte slice.

impl<'a> From<&'a ECPublicKey> for &'a [u8; 33]

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

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

Returns a reference to the underlying byte array.

impl From<[u8; 33]> for ECPublicKey

Converts a fixed-size byte array to an ECPublicKey.

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

Converts a 33-byte array into an EC public key.

impl From<ECPublicKey> for CBOR

Converts an ECPublicKey to CBOR.

fn from(value: ECPublicKey) -> Self

Converts to tagged CBOR.

impl Hash for ECPublicKey

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 ECPublicKey

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

Implements the Verifier trait for verifying signatures.

fn verify(&self, signature: &Signature, message: &dyn AsRef<[u8]>) -> bool

Verifies a signature for a message using this public key.

Only supports ECDSA signatures; returns false for other signature types.

impl Eq for ECPublicKey

impl StructuralPartialEq for ECPublicKey