use core::fmt;
use thiserror::Error;
use zeroize::{Zeroize, ZeroizeOnDrop};
const MAX_IDEMPOTENCY_KEY_BYTES: usize = 128;
#[derive(PartialEq, Eq, Zeroize, ZeroizeOnDrop)]
pub struct HolderHarnessFlowRequest {
credential_offer_launch_uri: String,
idempotency_key: String,
}
impl fmt::Debug for HolderHarnessFlowRequest {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HolderHarnessFlowRequest")
.field(
"credential_offer_launch_uri_bytes",
&self.credential_offer_launch_uri.len(),
)
.field("idempotency_key", &"<redacted>")
.finish()
}
}
impl HolderHarnessFlowRequest {
pub fn new(
credential_offer_launch_uri: String,
idempotency_key: String,
) -> Result<Self, HolderHarnessFlowError> {
if credential_offer_launch_uri.is_empty()
|| idempotency_key.is_empty()
|| idempotency_key.len() > MAX_IDEMPOTENCY_KEY_BYTES
|| !idempotency_key
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.'))
{
return Err(HolderHarnessFlowError::new(
HolderHarnessFlowErrorReason::LaunchRejected,
));
}
Ok(Self {
credential_offer_launch_uri,
idempotency_key,
})
}
#[cfg(feature = "axum-holder-harness")]
pub(crate) fn from_validated_launch(
credential_offer_launch_uri: String,
idempotency_key: String,
) -> Self {
Self {
credential_offer_launch_uri,
idempotency_key,
}
}
#[must_use]
pub fn credential_offer_launch_uri(&self) -> &str {
self.credential_offer_launch_uri.as_str()
}
#[must_use]
pub fn idempotency_key(&self) -> &str {
self.idempotency_key.as_str()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HolderHarnessFlowOutcome {
status: HolderHarnessFlowStatus,
rejection_reason: Option<HolderHarnessProtocolRejectionReason>,
}
impl HolderHarnessFlowOutcome {
#[must_use]
pub const fn credential_stored() -> Self {
Self {
status: HolderHarnessFlowStatus::CredentialStored,
rejection_reason: None,
}
}
#[must_use]
pub const fn deferred_credential_pending() -> Self {
Self {
status: HolderHarnessFlowStatus::DeferredCredentialPending,
rejection_reason: None,
}
}
#[must_use]
pub const fn protocol_rejected(reason: HolderHarnessProtocolRejectionReason) -> Self {
Self {
status: HolderHarnessFlowStatus::ProtocolRejected,
rejection_reason: Some(reason),
}
}
#[must_use]
pub const fn status(self) -> HolderHarnessFlowStatus {
self.status
}
#[must_use]
pub const fn rejection_reason(self) -> Option<HolderHarnessProtocolRejectionReason> {
self.rejection_reason
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HolderHarnessFlowStatus {
CredentialStored,
DeferredCredentialPending,
ProtocolRejected,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HolderHarnessProtocolRejectionReason {
IssuerMetadataIssuerMismatch,
AuthorizationServerIssuerMismatch,
AuthorizationIssuerMismatch,
AuthorizationIssuerMissing,
AuthorizationStateMismatch,
AuthorizationStateMissing,
}
pub trait HolderHarnessFlowDriver: Send + Sync {
fn drive_offer_launch(
&self,
request: &HolderHarnessFlowRequest,
) -> Result<HolderHarnessFlowOutcome, HolderHarnessFlowError>;
}
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq)]
#[error("holder harness flow failed: {reason}")]
pub struct HolderHarnessFlowError {
reason: HolderHarnessFlowErrorReason,
}
impl HolderHarnessFlowError {
#[must_use]
pub const fn new(reason: HolderHarnessFlowErrorReason) -> Self {
Self { reason }
}
#[must_use]
pub const fn reason(self) -> HolderHarnessFlowErrorReason {
self.reason
}
}
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq)]
pub enum HolderHarnessFlowErrorReason {
#[error("launch_rejected")]
LaunchRejected,
#[error("wallet_attestation_unavailable")]
WalletAttestationUnavailable,
#[error("token_exchange_failed")]
TokenExchangeFailed,
#[error("credential_request_failed")]
CredentialRequestFailed,
#[error("credential_storage_failed")]
CredentialStorageFailed,
}