Enum PublicKey 

pub enum PublicKey {
    Ed25519([u8; 32]),
    Secp256k1([u8; 64]),
}

Ed25519 or Secp256k1 public key.

Stored as fixed-size arrays matching nearcore’s representation:

• Ed25519: 32-byte compressed point
• Secp256k1: 64-byte uncompressed point (x, y coordinates, no 0x04 prefix)

Variants

Ed25519([u8; 32])

Ed25519 public key (32 bytes).

Secp256k1([u8; 64])

Secp256k1 public key (64 bytes, uncompressed without prefix).

This matches nearcore’s representation: raw x,y coordinates without the 0x04 uncompressed point prefix.

Implementations

impl PublicKey

pub fn ed25519_from_bytes(bytes: [u8; 32]) -> Self

Create an Ed25519 public key from raw 32 bytes.

pub fn secp256k1_from_bytes(bytes: [u8; 64]) -> Self

Create a Secp256k1 public key from raw 64-byte uncompressed coordinates.

The 64 bytes are the raw x,y coordinates without the 0x04 prefix, matching nearcore’s format.

Validates that the point is on the secp256k1 curve.

Panics

Panics if the bytes do not represent a valid point on the secp256k1 curve.

pub fn secp256k1_from_compressed(bytes: [u8; 33]) -> Self

Create a Secp256k1 public key from a compressed 33-byte SEC1 encoding.

The key is validated and stored internally in uncompressed (64-byte) format matching nearcore’s representation.

Panics

Panics if the bytes do not represent a valid point on the secp256k1 curve.

pub fn secp256k1_from_uncompressed(bytes: [u8; 65]) -> Self

Create a Secp256k1 public key from an uncompressed 65-byte SEC1 encoding (with 0x04 prefix).

The key is validated and stored internally without the prefix (64 bytes), matching nearcore’s format.

Panics

Panics if the bytes do not represent a valid point on the secp256k1 curve.

pub fn key_type(&self) -> KeyType

Get the key type.

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

Get the raw key bytes as a slice.

pub fn as_ed25519_bytes(&self) -> Option<&[u8; 32]>

Get the key data as a fixed-size array for Ed25519 keys.

pub fn as_secp256k1_bytes(&self) -> Option<&[u8; 64]>

Get the key data as a fixed-size array for Secp256k1 keys (64-byte uncompressed, no prefix).

Trait Implementations

impl BorshDeserialize for PublicKey

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for PublicKey

fn serialize<W: Write>(&self, writer: &mut W) -> Result<()>

impl Clone for PublicKey

fn clone(&self) -> PublicKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PublicKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PublicKey

where Self: FromStr, <Self as FromStr>::Err: Display,

fn deserialize<__D>(deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PublicKey

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

Formats the value using the given formatter.

impl FromStr for PublicKey

type Err = ParseKeyError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for PublicKey

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 PublicKey

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

where Self: Display,

fn serialize<__S>(&self, serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for PublicKey

type Error = ParseKeyError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for PublicKey

impl StructuralPartialEq for PublicKey