Enum StorageError 

pub enum StorageError {
    Keystore(String),
    BlobStore(String),
    Lock(String),
    Serialization(String),
    Crypto(String),
    InvalidEnvelope(String),
    InvalidInput(String),
    UnsupportedEnvelopeVersion(u32),
    VaultDb(String),
    CacheDb(String),
    PersistentStorage(String),
    InvalidLeafIndex {
        expected: u64,
        provided: u64,
    },
    CorruptedVault(String),
    NotInitialized,
    NullifierAlreadyDisclosed,
    CredentialNotFound,
    CredentialIdNotFound {
        credential_id: u64,
    },
    CorruptedCacheEntry {
        key_prefix: u8,
    },
    ActivityDb(String),
    ActivityInvalidRecord(String),
    UnexpectedUniFFICallbackError(String),
}

Errors raised by credential storage primitives.

Variants

Keystore(String)

Errors coming from the device keystore.

BlobStore(String)

Errors coming from the blob store.

Lock(String)

Errors coming from the storage lock.

Serialization(String)

Serialization/deserialization failures.

Crypto(String)

Cryptographic failures (AEAD, HKDF, etc.).

InvalidEnvelope(String)

Invalid or malformed account key envelope.

InvalidInput(String)

Invalid input supplied to a storage operation.

UnsupportedEnvelopeVersion(u32)

Unsupported envelope version.

VaultDb(String)

Errors coming from the vault database.

CacheDb(String)

Errors coming from the cache database.

PersistentStorage(String)

Errors initializing or administering persistent browser storage.

InvalidLeafIndex

Leaf index mismatch during initialization.

Fields

expected: u64

Leaf index stored in the vault.

provided: u64

Leaf index provided by the caller.

CorruptedVault(String)

Vault database integrity check failed.

NotInitialized

Storage has not been initialized yet.

NullifierAlreadyDisclosed

Nullifier already disclosed for a different request.

CredentialNotFound

Credential not found in the vault.

CredentialIdNotFound

Credential ID not found when deleting from the vault.

Fields

credential_id: u64

Credential ID provided by the caller.

CorruptedCacheEntry

Corrupted cache entry

Fields

key_prefix: u8

The prefix of the corrupted cache entry (identifies the type of entry).

ActivityDb(String)

Errors coming from the activity database.

ActivityInvalidRecord(String)

An ActivityEntry violated the failure_reason/outcome invariant.

UnexpectedUniFFICallbackError(String)

Unexpected UniFFI callback error.

Trait Implementations

impl<UT> ConvertError<UT> for StorageError

fn try_convert_unexpected_callback_error( e: UnexpectedUniFFICallbackError, ) -> Result<StorageError, Error>

impl Debug for StorageError

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

Formats the value using the given formatter.

impl Display for StorageError

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

Formats the value using the given formatter.

impl Error for StorageError

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<UT> FfiConverter<UT> for StorageError

const TYPE_ID_META: MetadataBuffer

Type ID metadata, serialized into a MetadataBuffer.

type FfiType = RustBuffer

The low-level type used for passing values of this type over the FFI.

fn lower(v: StorageError) -> RustBuffer

Lower a rust value of the target type, into an FFI value of type Self::FfiType.

fn try_lift(buf: RustBuffer) -> Result<StorageError, Error>

Lift a rust value of the target type, from an FFI value of type Self::FfiType.

fn write(obj: StorageError, buf: &mut Vec<u8>)

Write a rust value into a buffer, to send over the FFI in serialized form.

fn try_read(buf: &mut &[u8]) -> Result<StorageError, Error>

Read a rust value from a buffer, received over the FFI in serialized form.

impl From<StorageError> for WalletKitError

fn from(error: StorageError) -> WalletKitError

Converts to this type from the input type.

impl From<StorageError> for CredentialConstraintsCheckError

fn from(source: StorageError) -> CredentialConstraintsCheckError

Converts to this type from the input type.

impl From<StoreError> for StorageError

1-1 variant mapping is intentional: hosts pattern-match on StorageError for UX, and walletkit-db is uniffi-free by design, so the translation has to live in each FFI-exporting consumer. Don’t flatten.

TODO: when a second consumer (OrbKit, IssuerKit) ships its own uniffi-exported error mirroring StoreError, extract this mapping into a shared walletkit-ffi-shared crate. Not worth it for one consumer.

fn from(err: StoreError) -> StorageError

Converts to this type from the input type.

impl From<UnexpectedUniFFICallbackError> for StorageError

fn from(error: UnexpectedUniFFICallbackError) -> StorageError

Converts to this type from the input type.

impl<UT> Lift<UT> for StorageError

type FfiType = <StorageError as FfiConverter<UT>>::FfiType

fn try_lift( v: <StorageError as Lift<UT>>::FfiType, ) -> Result<StorageError, Error>

fn try_read(buf: &mut &[u8]) -> Result<StorageError, Error>

fn try_lift_from_rust_buffer(v: RustBuffer) -> Result<Self, Error>

Convenience method

impl<UT> LiftRef<UT> for StorageError

type LiftType = StorageError

impl<UT> LiftReturn<UT> for StorageError

type ReturnType = <StorageError as Lift<UT>>::FfiType

FFI return type for trait interfaces

fn try_lift_successful_return( v: <StorageError as LiftReturn<UT>>::ReturnType, ) -> Result<StorageError, Error>

Lift a successfully returned value from a trait interface

fn lift_foreign_return( ffi_return: Self::ReturnType, call_status: RustCallStatus, ) -> Self

Lift a foreign returned value from a trait interface

fn lift_error(_buf: RustBuffer) -> Self

Lift a Rust value for a callback interface method error result

fn handle_callback_unexpected_error(e: UnexpectedUniFFICallbackError) -> Self

Lift a Rust value for an unexpected callback interface error

impl<UT> Lower<UT> for StorageError

type FfiType = <StorageError as FfiConverter<UT>>::FfiType

fn lower(obj: StorageError) -> <StorageError as Lower<UT>>::FfiType

fn write(obj: StorageError, buf: &mut Vec<u8>)

fn lower_into_rust_buffer(obj: Self) -> RustBuffer

Convenience method

impl<UT> LowerError<UT> for StorageError

fn lower_error(obj: StorageError) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for StorageError

type ReturnType = <StorageError as Lower<UT>>::FfiType

The type that should be returned by scaffolding functions for this type.

fn lower_return( v: StorageError, ) -> Result<<StorageError as LowerReturn<UT>>::ReturnType, RustCallError>

Lower the return value from an scaffolding call

fn handle_failed_lift( error: LiftArgsError, ) -> Result<Self::ReturnType, RustCallError>

Lower the return value for failed argument lifts

impl<UT> TypeId<UT> for StorageError

const TYPE_ID_META: MetadataBuffer