Enum LastIDError 

#[non_exhaustive]
pub enum LastIDError {
    Config(String),
    Http(HttpError),
    TrustRegistry(TrustRegistryError),
    Crypto(String),
    InvalidCredential(String),
    Timeout(u64),
    PolicyValidation(String),
    Serialization(Error),
    Io(Error),
    TomlParse(Error),
    InvalidDid(String),
    EmptyClientId,
    InsecureUrl(String),
    ClockSkewExceeded {
        tolerance_seconds: u64,
    },
    TokenBindingMismatch {
        expected: String,
        actual: String,
    },
}

Top-level SDK error type.

All SDK operations return this error type, which encompasses configuration errors, HTTP errors, trust registry errors, cryptographic errors, and more.

Error Handling

Use pattern matching to handle specific error cases:

use lastid_sdk::{HttpError, LastIDError};

fn handle_error(err: LastIDError) {
    match err {
        LastIDError::Http(HttpError::RateLimited {
            retry_after_seconds,
        }) => {
            println!(
                "Rate limited, retry after {} seconds",
                retry_after_seconds
            );
        }
        LastIDError::TrustRegistry(e) => {
            println!("Trust registry error: {}", e);
        }
        LastIDError::Timeout(seconds) => {
            println!("Request timed out after {} seconds", seconds);
        }
        _ => println!("Error: {}", err),
    }
}

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.

Config(String)

Configuration error (missing or invalid config)

Http(HttpError)

HTTP request failed

TrustRegistry(TrustRegistryError)

Trust registry error

Crypto(String)

Cryptographic operation failed

InvalidCredential(String)

Invalid credential (parsing or validation failed)

Timeout(u64)

Request timeout

PolicyValidation(String)

Policy validation failed

Serialization(Error)

Serialization error

Io(Error)

IO error

TomlParse(Error)

TOML parsing error

InvalidDid(String)

Invalid DID format

EmptyClientId

Invalid client ID (empty or whitespace-only)

InsecureUrl(String)

HTTP URL not allowed in production (SEC-001)

ClockSkewExceeded

Clock skew exceeded tolerance (SEC-005)

Fields

tolerance_seconds: u64

Maximum allowed clock skew in seconds

TokenBindingMismatch

DPoP token binding mismatch (SEC-004)

Fields

expected: String

Expected JWK thumbprint from our DPoP key

actual: String

Actual JWK thumbprint from token’s cnf.jkt claim

Implementations

impl LastIDError

pub fn config(message: impl Into<String>) -> Self

Create a configuration error.

pub fn crypto(message: impl Into<String>) -> Self

Create a crypto error.

pub fn invalid_credential(message: impl Into<String>) -> Self

Create an invalid credential error.

pub fn credential_parse(message: impl Into<String>) -> Self

Create a credential parsing error.

This is an alias for invalid_credential used specifically when TryFrom conversions fail due to type mismatch or missing required fields.

Example

use lastid_sdk::LastIDError;

let err = LastIDError::credential_parse("Expected LastID.Persona, got LastID.Employment");
assert!(err.to_string().contains("LastID.Persona"));

pub fn policy_validation(message: impl Into<String>) -> Self

Create a policy validation error.

pub fn is_retryable(&self) -> bool

Check if this error is retryable.

pub fn suggested_retry_delay_ms(&self) -> Option<u64>

Get suggested retry delay in milliseconds.

Returns Some(delay) for retryable errors with a recommended wait time. Returns None for non-retryable errors.

Retry Strategy Hints

• Rate limited: Use the retry_after value from the response
• Network errors: Start with short delays (100-500ms), use exponential backoff
• Server errors (5xx): Use moderate delays (1-5s), with exponential backoff
• Timeout: Increase timeout or use exponential backoff

Example

use lastid_sdk::LastIDError;

fn should_retry(err: &LastIDError, attempt: u32) -> Option<u64> {
    if !err.is_retryable() || attempt >= 3 {
        return None;
    }
    err.suggested_retry_delay_ms()
}

pub const fn category(&self) -> &'static str

Get the error category for logging and metrics.

Returns a static string describing the error category, useful for structured logging and metrics.

pub fn invalid_did(did: impl Into<String>) -> Self

Create an invalid DID error.

pub fn insecure_url(url: impl Into<String>) -> Self

Create an insecure URL error.

pub const fn clock_skew_exceeded(tolerance_seconds: u64) -> Self

Create a clock skew exceeded error.

pub fn token_binding_mismatch( expected: impl Into<String>, actual: impl Into<String>, ) -> Self

Create a token binding mismatch error.

Trait Implementations

impl Debug for LastIDError

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

Formats the value using the given formatter.

impl Display for LastIDError

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

Formats the value using the given formatter.

impl Error for LastIDError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for LastIDError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for LastIDError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for LastIDError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<HttpError> for LastIDError

fn from(source: HttpError) -> Self

Converts to this type from the input type.

impl From<TrustRegistryError> for LastIDError

fn from(source: TrustRegistryError) -> Self

Converts to this type from the input type.