Enum RejectReason 

pub enum RejectReason {
    MalformedRequest {
        reason: String,
    },
    UnsupportedType {
        type_uri: String,
    },
    UnsupportedVersion {
        type_uri: String,
    },
    Expired {
        expires_at: DateTime<Utc>,
    },
    Stale {
        detail: StaleReason,
    },
    IdConflict,
    ProofRequired,
    ProofInvalid {
        reason: String,
    },
    PermissionDenied {
        reason: String,
    },
    WrongRecipient {
        in_band: String,
        expected: String,
    },
    IdentityMismatch(ConsistencyError),
    TaskFailed {
        reason: String,
        details: Option<Value>,
    },
    Unavailable {
        retry_after: Option<DateTime<Utc>>,
    },
    InternalError {
        reason: String,
    },
}

Typed rejection conditions a conforming consumer raises while applying SPEC.md §7.2.

Each variant carries the context needed to render a meaningful operator message and maps to a single StandardCode from §8.3. The From impl produces an ErrorPayload with the matching code, retryable default, and a message derived from the variant’s fields.

Use this on the consumer side to turn ?-propagated errors from resolve_parties / validate_basic / your own task logic into a well-formed error response.

Variants

MalformedRequest

The document did not validate against the framework or payload schema.

Fields

reason: String

Human-readable explanation, surfaced as message in the response.

UnsupportedType

The consumer does not implement this type URI.

Fields

type_uri: String

The unsupported Type URI as it appeared in the document.

UnsupportedVersion

The consumer recognizes the type but not at this MAJOR.MINOR.

Fields

type_uri: String

The unsupported Type URI as it appeared in the document.

Expired

The document’s expiresAt was in the past.

Fields

expires_at: DateTime<Utc>

The expiry timestamp carried in the rejected document.

Stale

The document falls outside the consumer’s acceptance window (SPEC.md §7.2, Bounding the record) — either because its issuedAt is older than the window, or because it carries no timestamp the consumer can place in one.

Reported as expired: §8.3 defines no separate code, and the window is the consumer’s own bound on when it is still willing to act, which is what expired means to the producer.

Fields

detail: StaleReason

Which of the two window failures occurred. For the operator’s log; both render the same wire message.

IdConflict

The document’s id matches one the consumer has already accepted, but its content differs (SPEC.md §7.2 item 11).

The later document MUST NOT be treated as a retry of the original.

ProofRequired

A proof was required by the spec or consumer policy but was missing.

ProofInvalid

A proof was present but failed verification.

Fields

reason: String

Human-readable explanation, surfaced as message.

PermissionDenied

The requesting party is not authorized to invoke this task.

Fields

reason: String

Human-readable explanation, surfaced as message.

WrongRecipient

The document’s recipient is set but does not identify the consumer.

Fields

in_band: String

Value carried by the document’s recipient member.

expected: String

VID of the consumer that received the document.

IdentityMismatch(ConsistencyError)

An in-band party identity contradicts the transport-derived value.

TaskFailed

The task was attempted but could not be completed.

Fields

reason: String

Human-readable explanation, surfaced as message.

details: Option<Value>

Optional spec-defined extension data; carried verbatim into ErrorPayload::details.

Unavailable

The consumer is temporarily unable to process the task.

Fields

retry_after: Option<DateTime<Utc>>

Optional retry-after hint, surfaced as retryAfter.

InternalError

The consumer encountered an unexpected internal failure.

Fields

reason: String

Human-readable explanation, surfaced as message.

Implementations

impl RejectReason

pub fn code(&self) -> StandardCode

The StandardCode that corresponds to this rejection.

pub fn wire_message(&self) -> String

Message safe to attach to a wire-serialised ErrorPayload.

SPEC.md §8.1 (final paragraph) and §10.4 require error-response messages to be free of consumer-side authentication context. The Display implementation (and to_string()) is intentionally chatty for diagnostic purposes — it names both the in-band and the transport-authenticated identities under Self::IdentityMismatch and the consumer’s own VID under Self::WrongRecipient, which makes log lines actionable but is exactly the identity oracle a wire-exposed message must not provide.

Variants whose Display is already consumer-side-neutral (Expired, ProofRequired, …) return the same string the Display would. The variants that would otherwise leak consumer-side state return a sanitised constant.

ProofInvalid is sanitised

SPEC §10.4 states the rule for identityMismatch and then generalises it: “the same principle applies to every standard code: error messages SHOULD be derived from the code identifier and the Trust Task specification’s public vocabulary, not from consumer-side authentication context.”

A ProofInvalid { reason } built from a verifier’s error text is exactly that context. Real strings a cryptosuite backend produces include resolve did:web:x: connection refused, verificationMethod … not present in DID document, and verificationMethod is controlled by {vm_did}, not the document issuer {issuer}. Returned on the wire to an unauthenticated sender — the proof did not verify, so the sender is by definition not authenticated — those answer questions the sender asked by choosing what to put in proof: which DIDs this consumer can reach, whether a resolver is up, and what a DID document it fetched contains. That is a resolver-reachability and DID-document oracle, free of charge and at the sender’s chosen rate.

The reason remains on the Display impl, which is where the operator reads it.

pub fn malformed_from_serde(err: &Error) -> RejectReason

Build a malformedRequest from a serde_json failure without echoing the deserializer’s pointer into the document.

serde_json::Error::to_string() renders as, for example, missing field 'subject' at line 1 column 214 or unknown field 'admin', expected one of … — the member path, the offset, and sometimes the full set of expected members. On the wire that describes the consumer’s internal type layout to anyone willing to send malformed JSON, and the offsets describe how the consumer framed the body.

This maps the error to its category — which is what a producer can act on — and leaves the detail for the log. Transport bindings that deserialize a body themselves should use this rather than format!("{e}"), so one rule holds across the framework.

Trait Implementations

impl Clone for RejectReason

fn clone(&self) -> RejectReason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RejectReason

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

Formats the value using the given formatter.

impl Display for RejectReason

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

Formats the value using the given formatter.

impl Eq for RejectReason

impl Error for RejectReason

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<ConsistencyError> for RejectReason

fn from(source: ConsistencyError) -> RejectReason

Converts to this type from the input type.

impl From<RejectReason> for ErrorPayload

fn from(reason: RejectReason) -> ErrorPayload

Converts to this type from the input type.

impl From<ReplayGuardError> for RejectReason

fn from(_: ReplayGuardError) -> RejectReason

Converts to this type from the input type.

impl PartialEq for RejectReason

fn eq(&self, other: &RejectReason) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RejectReason