Struct ECUncompressedPublicKey 

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

An uncompressed elliptic curve digital signature algorithm (ECDSA) public key.

An ECUncompressedPublicKey is a 65-byte representation of a public key on the secp256k1 curve. It consists of:

• 1 byte prefix (0x04)
• 32 bytes for the x-coordinate
• 32 bytes for the y-coordinate

This format explicitly includes both coordinates of the elliptic curve point, unlike the compressed format which only includes the x-coordinate and a single byte to indicate the parity of the y-coordinate.

This is considered a legacy key type and is not recommended for general use. The compressed format (ECPublicKey) is more space-efficient and provides the same cryptographic security. However, some legacy systems or protocols might require the uncompressed format.

Examples

Converting between compressed and uncompressed formats:

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

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

// Convert to uncompressed format
let uncompressed_key = compressed_key.uncompressed_public_key();

// Convert back to compressed format
let compressed_again = uncompressed_key.public_key();

// They should be equal
assert_eq!(compressed_key, compressed_again);

Implementations

impl ECUncompressedPublicKey

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

Restores an ECDSA uncompressed public key from an array of bytes.

This method performs no validation on the input data.

Trait Implementations

impl AsRef<[u8]> for ECUncompressedPublicKey

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 ECUncompressedPublicKey

Defines CBOR tags for EC keys.

fn cbor_tags() -> Vec<Tag>

Returns the CBOR tags for EC keys.

impl CBORTaggedEncodable for ECUncompressedPublicKey

Implements CBOR encoding for EC uncompressed 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

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 ECUncompressedPublicKey

fn clone(&self) -> ECUncompressedPublicKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ECUncompressedPublicKey

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 ECUncompressedPublicKey

Formats the key as a hexadecimal string.

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

Displays the key as a hexadecimal string.

impl ECKey for ECUncompressedPublicKey

Implements the ECKey trait for converting to compressed format.

fn public_key(&self) -> ECPublicKey

Converts this uncompressed public key to its compressed form.

impl ECKeyBase for ECUncompressedPublicKey

Implements the ECKeyBase trait methods for ECUncompressedPublicKey.

const KEY_SIZE: usize = 65usize

The size of an EC uncompressed public key (65 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 ECUncompressedPublicKey

Implements the ECPublicKeyBase trait.

fn uncompressed_public_key(&self) -> ECUncompressedPublicKey

Returns this uncompressed public key (self).

impl From<[u8; 65]> for ECUncompressedPublicKey

Converts a fixed-size byte array to an ECUncompressedPublicKey.

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

Converts a 65-byte array into an EC uncompressed public key.

impl From<ECUncompressedPublicKey> for CBOR

Converts an ECUncompressedPublicKey to CBOR.

fn from(value: ECUncompressedPublicKey) -> Self

Converts to tagged CBOR.

impl Hash for ECUncompressedPublicKey

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 ECUncompressedPublicKey

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

impl StructuralPartialEq for ECUncompressedPublicKey