Enum OrgError 

#[non_exhaustive]
pub enum OrgError {
    AdminNotFound {
        org: String,
    },
    MemberNotFound {
        org: String,
        did: String,
    },
    AlreadyRevoked {
        did: String,
    },
    InvalidCapability {
        cap: String,
        reason: String,
    },
    InvalidDid(String),
    InvalidPublicKey(String),
    Signing(String),
    Identity(String),
    KeyStorage(String),
    Storage(RegistryError),
    Anchor(AnchorError),
    OrgThresholdDelegationUnsupported {
        org: String,
    },
    MemberKeyExists {
        alias: String,
    },
    MemberNotDelegable {
        did: String,
        org: String,
    },
    CryptoError(AgentError),
    Delegation(InitError),
    IdentityExists {
        location: String,
    },
    IdentityInit(InitError),
    Attestation(AttestationError),
    Bundle(OrgBundleError),
    PolicyCompile {
        reason: String,
    },
    OidcPolicyInvalid {
        reason: String,
    },
    PolicyBlobMissing {
        hash: String,
    },
    PolicyIntegrity {
        expected: String,
        actual: String,
    },
    ChainCycle {
        did: String,
    },
    ChainTooDeep {
        max: u32,
    },
    ChainBrokenHop {
        did: String,
    },
}

Errors from organization member management workflows.

Usage:

match result {
    Err(OrgError::AdminNotFound { .. }) => { /* 403 Forbidden */ }
    Err(OrgError::MemberNotFound { .. }) => { /* 404 Not Found */ }
    Err(e) => return Err(e.into()),
    Ok(att) => { /* proceed */ }
}

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.

AdminNotFound

No admin matching the given public key was found in the organization.

Fields

org: String

The organization identifier.

MemberNotFound

The specified member was not found in the organization.

Fields

org: String

The organization identifier.

did: String

The DID of the member that was not found.

AlreadyRevoked

The member has already been revoked.

Fields

did: String

The DID of the already-revoked member.

InvalidCapability

The capability string could not be parsed.

Fields

cap: String

The invalid capability string.

reason: String

The reason parsing failed.

InvalidDid(String)

The organization DID is malformed.

InvalidPublicKey(String)

The hex-encoded public key is invalid.

Signing(String)

A signing operation failed while creating or revoking an attestation.

Identity(String)

The identity could not be loaded from storage.

KeyStorage(String)

A key storage operation failed.

Storage(RegistryError)

A storage operation failed.

Anchor(AnchorError)

KEL anchoring failed.

OrgThresholdDelegationUnsupported

The organization’s controller threshold is kt≥2 (multi-signature). KERI-native member delegation currently anchors single-author (kt=1) interaction events only; multi-sig org anchoring is a tracked follow-up.

Fields

org: String

The organization identifier.

MemberKeyExists

A key already exists under the requested member alias — minting a member there would clobber an existing delegated key. Choose a fresh alias.

Fields

alias: String

The keychain alias already in use.

MemberNotDelegable

The supplied member identity is not a delegated identifier of this org — its delegated inception (dip) does not name the org as delegator, so the org cannot off-board it. Fail closed.

Fields

did: String

The member’s did:keri:.

org: String

The organization identifier.

CryptoError(AgentError)

A cryptographic operation failed (e.g. resolving the org key’s curve).

Delegation(InitError)

Authoring or anchoring the member’s delegated identifier failed.

IdentityExists

An identity already exists where the org would be created — refusing to clobber it.

Fields

location: String

Where the existing identity was found (repository path or registry).

IdentityInit(InitError)

Initializing the organization’s KERI identity failed.

Attestation(AttestationError)

Creating the organization’s admin self-attestation failed.

Bundle(OrgBundleError)

An air-gapped bundle failed offline verification (tampered event, missing member KEL, missing delegation seal, or an invalid off-boarding record). The fail-closed detail is the typed auths_verifier::org_bundle::OrgBundleError.

PolicyCompile

The supplied org policy did not parse or compile (invalid JSON, an invalid DID/capability/glob, or it exceeds the policy size/complexity bounds). A policy that does not compile is never anchored — fail closed.

Fields

reason: String

The compile/parse failure(s).

OidcPolicyInvalid

The supplied OIDC-subject policy did not parse (invalid JSON or empty required fields). A policy that does not parse is never anchored — fail closed.

Fields

reason: String

The parse failure.

PolicyBlobMissing

The org KEL anchors a policy hash but its content-addressed blob is missing — the policy cannot be loaded, so authority cannot be evaluated. Fail closed.

Fields

hash: String

The policy source-hash anchored on the org KEL.

PolicyIntegrity

The loaded policy blob does not hash to the value the org KEL committed — the blob was tampered with after anchoring. Fail closed.

Fields

expected: String

The hash anchored on the org KEL.

actual: String

The recomputed hash of the stored blob.

ChainCycle

A delegation chain walk followed a di link back to an identifier already on the chain — a cyclic/malformed delegation. Fail closed (no infinite loop).

Fields

did: String

The identifier the cycle returned to.

ChainTooDeep

A delegation chain exceeds the maximum hop depth the walker will follow.

Fields

max: u32

The maximum number of hops allowed.

ChainBrokenHop

A delegation chain names a delegator/identifier whose KEL is absent from storage — the chain cannot be reconstructed. Fail closed.

Fields

did: String

The identifier whose KEL is missing.

Trait Implementations

impl AuthsErrorInfo for OrgError

fn error_code(&self) -> &'static str

Returns a unique error code string for this error variant.

fn suggestion(&self) -> Option<&'static str>

Returns an optional actionable suggestion for resolving the error.

impl Debug for OrgError

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

Formats the value using the given formatter.

impl Display for OrgError

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

Formats the value using the given formatter.

impl Error for OrgError

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<AnchorError> for OrgError

fn from(source: AnchorError) -> Self

Converts to this type from the input type.

impl From<OrgBundleError> for OrgError

fn from(source: OrgBundleError) -> Self

Converts to this type from the input type.

impl From<OrgError> for ComplianceQueryError

fn from(source: OrgError) -> Self

Converts to this type from the input type.

impl From<OrgError> for CommitTrustError

fn from(source: OrgError) -> Self

Converts to this type from the input type.