Struct DevicePublicKey 

pub struct DevicePublicKey { /* private fields */ }

A device public key carrying its curve type explicitly.

Curve is stored alongside the raw key bytes so dispatch never relies on key length — adding a new curve that shares a byte length (e.g. secp256k1, also 33 bytes compressed) won’t break existing match arms.

Accepted byte lengths per curve:

• Ed25519: 32
• P-256: 33 (compressed SEC1) or 65 (uncompressed SEC1)

Implementations

impl DevicePublicKey

pub fn try_new(curve: CurveType, bytes: &[u8]) -> Result<Self, InvalidKeyError>

Create from a curve type and raw bytes, validating length per curve.

Args:

• curve: Which elliptic curve this key belongs to.
• bytes: Raw public key bytes.

Usage:

let pk = DevicePublicKey::try_new(CurveType::Ed25519, &key_bytes)?;

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

Create an Ed25519 device key from raw 32-byte key.

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

Create a P-256 device key from raw SEC1 bytes (33 compressed or 65 uncompressed).

Returns Err if bytes is not 33 or 65 bytes.

pub fn curve(&self) -> CurveType

Returns the curve type.

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

Returns the raw key bytes.

pub fn is_zero(&self) -> bool

Returns true if all bytes are zero.

pub fn len(&self) -> usize

Returns the byte length.

pub fn is_empty(&self) -> bool

Returns true if empty.

pub async fn verify( &self, message: &[u8], signature: &[u8], provider: &dyn CryptoProvider, ) -> Result<(), SignatureVerifyError>

Verify a signature against this key, dispatching on curve.

This is the single canonical verify method — every caller that holds a DevicePublicKey should call this rather than branching on curve themselves. Adding a new curve means updating this one impl; the compiler then flags every call site still assuming only Ed25519.

Args:

• message: Payload bytes that were signed.
• signature: Raw signature bytes (64 for Ed25519 / P-256).
• provider: Pluggable crypto provider (RingCryptoProvider native, WebCryptoProvider wasm) — used for Ed25519. P-256 routes through RingCryptoProvider::p256_verify on native.

Usage:

issuer_pk.verify(&payload, &signature, provider).await?;

Trait Implementations

impl Clone for DevicePublicKey

fn clone(&self) -> DevicePublicKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DevicePublicKey

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

Formats the value using the given formatter.

impl Default for DevicePublicKey

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DevicePublicKey

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for DevicePublicKey

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

Formats the value using the given formatter.

impl Eq for DevicePublicKey

impl From<Ed25519PublicKey> for DevicePublicKey

fn from(pk: Ed25519PublicKey) -> Self

Converts to this type from the input type.

impl Hash for DevicePublicKey

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 DevicePublicKey

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

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.