Enum EnvelopeError 

#[non_exhaustive]
pub enum EnvelopeError {
    Unsigned {
        status: u16,
    },
    Unverified,
    ContractUnsupported {
        op: String,
    },
    Seal(CratestackError),
    Open(CratestackError),
    UnexpectedPayloadType {
        got: String,
    },
    StreamsUnsupported,
}

A failure that belongs to the signed transport, not to the call.

A client that has an envelope never falls back to a plain call: every one of these is an error, and none of them carries a decoded body. In particular an answer that arrives without a seal is Unsigned whatever its status, so a proxy that strips the envelope, or a server that was never asked to sign, cannot turn a Required client into a plain one.

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.

Unsigned

The response was not a COSE message. Nothing in its body was read.

The layer’s own refusals (a wrong audience, a stale iat, an unsupported media type, an oversized body) are always unsigned (ADR 0006 D4), so a 401 here usually means the server did not accept the request, not that a proxy tampered with the answer.

Fields

status: u16

Unverified

The response is a COSE message that failed verification: a bad signature or tag, an unknown key, or an answer sealed for a different request, status, route or key. The reason is deliberately not reported (ADR 0006 §10).

ContractUnsupported

The server answered the unsigned 426 whose body code is contract_unsupported (RPC) or CONTRACT_UNSUPPORTED (REST): it no longer serves the wire shape this client has for op (a breaking change to that op since this client was built), so the call was refused before any key was looked up. The answer is unsigned, so it is a hint and never proof: anyone on the path could send it, and a caller should offer “update the app” for that feature, not treat the server’s contract as known. Its body is read only for that code, which is unauthenticated; a 426 with any other code is Unsigned. Calls to other ops are unaffected. op is "METHOD /template" on REST and the op id on RPC.

Fields

op: String

Seal(CratestackError)

Sealing the request failed: the signer (a keystore, a KMS) refused or failed, or the envelope was misconfigured. Nothing was sent.

Open(CratestackError)

Opening the response failed for a reason that is not the message’s: the key resolver’s backend is down.

UnexpectedPayloadType

The response was sealed under a payload type the call did not ask for (its Cratestack-Payload-Type, absent meaning application/cbor, is not among the types the request advertised). The body was not opened, let alone decoded: a client never decodes a type it did not request. got is what the server named, truncated.

Fields

got: String

StreamsUnsupported

Streams and subscriptions cannot be sealed yet (ADR 0006 P1); the call was refused locally instead of being sent in plain.

Implementations

impl EnvelopeError

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

A stable identifier, for a caller that must tell the failures apart without matching on this enum (the FFI bridge reports it as the error’s remote_code).

Trait Implementations

impl Debug for EnvelopeError

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

Formats the value using the given formatter.

impl Display for EnvelopeError

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

Formats the value using the given formatter.

impl Error for EnvelopeError

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<EnvelopeError> for ClientError

fn from(source: EnvelopeError) -> Self

Converts to this type from the input type.

impl From<EnvelopeError> for RpcClientError

fn from(source: EnvelopeError) -> Self

Converts to this type from the input type.