Enum DerivedPublicKey 

#[non_exhaustive]
pub enum DerivedPublicKey {
    Secp256k1Compressed([u8; 33]),
    Secp256k1Uncompressed([u8; 65]),
    Ed25519([u8; 32]),
    Secp256k1XOnly([u8; 32]),
}

Strongly typed public key emitted by an HD derivation.

Each variant fixes its length and cryptographic algorithm at the type level, so consumers can branch on kind (or pattern match) instead of inspecting a raw byte slice.

Chain mapping

Chain(s)	Variant	Length
kobe-btc, kobe-cosmos, kobe-spark, kobe-xrpl	Secp256k1Compressed	33 B
kobe-evm, kobe-fil, kobe-tron	Secp256k1Uncompressed	65 B
kobe-svm, kobe-sui, kobe-aptos, kobe-ton	Ed25519	32 B
kobe-nostr	Secp256k1XOnly	32 B

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Secp256k1Compressed([u8; 33])

secp256k1 compressed SEC1 encoding (0x02/0x03 prefix + 32-byte x).

Secp256k1Uncompressed([u8; 65])

secp256k1 uncompressed SEC1 encoding (0x04 prefix + 32-byte x + 32-byte y).

Ed25519([u8; 32])

Ed25519 32-byte public key (RFC 8032 §5.1.5).

Secp256k1XOnly([u8; 32])

BIP-340 x-only secp256k1 public key (32-byte x, parity dropped).

Implementations

impl DerivedPublicKey

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

Borrow the raw bytes regardless of variant.

pub const fn byte_len(&self) -> usize

Length of the key in bytes.

The method is named byte_len rather than len because a key is not a collection: the “length” is a constant per variant and has no emptiness invariant to pair with.

pub fn to_hex(&self) -> String

Lowercase hex encoding of the raw key bytes.

pub const fn kind(&self) -> PublicKeyKind

Cryptographic algorithm / encoding tag.

pub fn compressed(bytes: &[u8]) -> Result<Self, DeriveError>

Try to build Secp256k1Compressed from a byte slice.

Errors

Returns DeriveError::Crypto if the slice is not exactly 33 bytes long.

pub fn uncompressed(bytes: &[u8]) -> Result<Self, DeriveError>

Try to build Secp256k1Uncompressed from a byte slice.

Errors

Returns DeriveError::Crypto if the slice is not exactly 65 bytes long.

Trait Implementations

impl AsRef<[u8]> for DerivedPublicKey

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

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

impl Clone for DerivedPublicKey

fn clone(&self) -> DerivedPublicKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DerivedPublicKey

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

Formats the value using the given formatter.

impl Hash for DerivedPublicKey

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 DerivedPublicKey

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

impl StructuralPartialEq for DerivedPublicKey