walletkit-web 0.21.3 → 0.22.1

package/dist/generated/walletkit_core.d.ts

@@ -12,6 +12,14 @@ import { type FfiConverter, type RustBufferAllocator, type UniffiByteArray, type
  * - [`CredentialConstraintsCheckError::ConstraintTooLarge`] if the constraint tree exceeds the node limit.
  */
 export declare function checkCredentialsAgainstProofRequest(request: ProofRequestLike, store: CredentialStoreLike, now: bigint): CredentialConstraintsCheckResult;
+/**
+ * Deletes the host-owned key envelope after closing/destroying its credential store.
+ * This does not invalidate keys already held in memory by other owners.
+ *
+ * # Errors
+ * Returns an error if locking or envelope deletion fails.
+ */
+export declare function deleteStorageKeyEnvelope(paths: StoragePathsLike, blobStore: AtomicBlobStore): void;
 /**
  * Emits a message at the given level through `WalletKit`'s tracing pipeline.
  *
@@ -33,6 +41,34 @@ export declare function emitLog(level: LogLevel, message: string): void;
  * Panics if the dedicated logger delivery thread cannot be spawned (native only).
  */
 export declare function initLogging(logger: Logger, level: LogLevel | undefined): void;
+/**
+ * Installs persistent encrypted browser storage in the current Web Worker.
+ *
+ * This must be awaited once before initializing a [`crate::storage::CredentialStore`] on
+ * WASM. The function fails when called outside a supported dedicated worker
+ * or when another browsing context owns the same OPFS SAH pool.
+ *
+ * # Errors
+ *
+ * Returns [`StorageError::PersistentStorage`] when OPFS setup fails.
+ */
+export declare function initializePersistentStorage(asyncOpts_?: {
+    signal: AbortSignal;
+}): Promise<void>;
+/**
+ * Opens the device-sealed key envelope, or generates and persists one if absent.
+ *
+ * Call this before constructing a credential store. Platform components are
+ * used only during this call and are not retained.
+ *
+ * `now` is Unix time in seconds, used only for a new envelope's creation and
+ * update timestamps. It is ignored when opening an existing envelope.
+ *
+ * # Errors
+ * Returns an error if locking, envelope access, key generation, sealing, or
+ * unsealing fails.
+ */
+export declare function openOrCreateStorageKeys(paths: StoragePathsLike, keystore: DeviceKeystore, blobStore: AtomicBlobStore, now: bigint): StorageKeysLike;
 /**
  * Derives recovery data from a 32-byte seed.
  *
@@ -64,6 +100,144 @@ export declare function recoveryDataFromSeed(seed: ArrayBuffer): RecoveryData;
  * is not in canonical form, or is the `BabyJubJub` identity point.
  */
 export declare function validateAuthenticatorPubkey(authenticatorPubkey: string): string;
+/**
+ * Which World ID protocol handled a proof-share request.
+ */
+export declare enum ProtocolVersion {
+    /**
+     * Legacy Semaphore-based protocol.
+     */
+    V3 = 3,
+    /**
+     * Current. Reference: <https://github.com/worldcoin/world-id-protocol/tree/main/docs/world-id-4-specs>
+     */
+    V4 = 4
+}
+/**
+ * Terminal outcome of a proof-share request.
+ */
+export declare enum ActivityOutcome {
+    /**
+     * Proof request was completed successfully.
+     */
+    Completed = 0,
+    /**
+     * The user declined the request.
+     */
+    Declined = 1,
+    /**
+     * The user cancelled or dismissed the request without an explicit decline.
+     */
+    Cancelled = 2,
+    /**
+     * The request failed (see [`ActivityFailureReason`]).
+     */
+    Failed = 3,
+    /**
+     * The request never reached a terminal outcome (e.g. the app was killed
+     * or backgrounded before completion).
+     */
+    Incomplete = 4
+}
+/**
+ * Reasons a proof fails.
+ */
+export declare enum ActivityFailureReason {
+    /**
+     * A network request failed.
+     */
+    NetworkError = 0,
+    /**
+     * The request timed out.
+     */
+    Timeout = 1,
+    /**
+     * Device authentication (e.g. Face ID/passcode) failed.
+     */
+    DeviceAuthenticationFailed = 2,
+    /**
+     * Proof generation itself failed.
+     */
+    ProofGenerationFailed = 3,
+    /**
+     * The relying party rejected the proof.
+     */
+    RelyingPartyRejected = 4
+}
+/**
+ * A single row of credential activity history.
+ */
+export type ActivityEntry = {
+    /**
+     * Unique identifier for this entry.
+     */
+    id?: bigint;
+    /**
+     * The relying party identifier.
+     */
+    rpId: bigint;
+    /**
+     * Host-app-defined identifier correlating this entry with its request.
+     */
+    clientId: string;
+    /**
+     * Protocol used for this request.
+     */
+    protocol: ProtocolVersion;
+    /**
+     * Activity time.
+     */
+    timestamp?: bigint;
+    /**
+     * The result of the activity.
+     */
+    outcome: ActivityOutcome;
+    /**
+     * The credentials which produced an output proof for the request.
+     */
+    issuerSchemaIds: Array<bigint>;
+    /**
+     * Present only when `outcome` is `Failed`.
+     */
+    failureReason?: ActivityFailureReason;
+};
+/**
+ * Generated factory for {@link ActivityEntry} record objects.
+ */
+export declare const ActivityEntry: Readonly<{
+    create: (partial: Partial<ActivityEntry> & Required<Omit<ActivityEntry, "id" | "timestamp" | "failureReason">>) => ActivityEntry;
+    new: (partial: Partial<ActivityEntry> & Required<Omit<ActivityEntry, "id" | "timestamp" | "failureReason">>) => ActivityEntry;
+    defaults: () => Partial<ActivityEntry>;
+}>;
+/**
+ * Aggregate counts over credential activity history.
+ */
+export type ActivityMetadata = {
+    /**
+     * Total number of recorded entries.
+     */
+    totalCount: bigint;
+};
+/**
+ * Generated factory for {@link ActivityMetadata} record objects.
+ */
+export declare const ActivityMetadata: Readonly<{
+    create: (partial: Partial<ActivityMetadata> & Required<Omit<ActivityMetadata, never>>) => ActivityMetadata;
+    new: (partial: Partial<ActivityMetadata> & Required<Omit<ActivityMetadata, never>>) => ActivityMetadata;
+    defaults: () => Partial<ActivityMetadata>;
+}>;
+/**
+ * Filtering/sorting options for [`super::CredentialStore::list_activities`].
+ */
+export type ActivityQuery = {};
+/**
+ * Generated factory for {@link ActivityQuery} record objects.
+ */
+export declare const ActivityQuery: Readonly<{
+    create: (partial: Partial<ActivityQuery> & Required<Omit<ActivityQuery, never>>) => ActivityQuery;
+    new: (partial: Partial<ActivityQuery> & Required<Omit<ActivityQuery, never>>) => ActivityQuery;
+    defaults: () => Partial<ActivityQuery>;
+}>;
 /**
  * Check result for a single request item.
  */
@@ -273,9 +447,11 @@ export declare enum StorageError_Tags {
     Serialization = "Serialization",
     Crypto = "Crypto",
     InvalidEnvelope = "InvalidEnvelope",
+    InvalidInput = "InvalidInput",
     UnsupportedEnvelopeVersion = "UnsupportedEnvelopeVersion",
     VaultDb = "VaultDb",
     CacheDb = "CacheDb",
+    PersistentStorage = "PersistentStorage",
     InvalidLeafIndex = "InvalidLeafIndex",
     CorruptedVault = "CorruptedVault",
     NotInitialized = "NotInitialized",
@@ -283,6 +459,8 @@ export declare enum StorageError_Tags {
     CredentialNotFound = "CredentialNotFound",
     CredentialIdNotFound = "CredentialIdNotFound",
     CorruptedCacheEntry = "CorruptedCacheEntry",
+    ActivityDb = "ActivityDb",
+    ActivityInvalidRecord = "ActivityInvalidRecord",
     UnexpectedUniFfiCallbackError = "UnexpectedUniFfiCallbackError"
 }
 /**
@@ -692,6 +870,73 @@ export declare const StorageError: Readonly<{
             cause?: unknown;
         }): Readonly<[string]>;
     };
+    InvalidInput: {
+        new (v0: string): {
+            readonly tag: StorageError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: StorageError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: StorageError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: StorageError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: StorageError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+    };
     UnsupportedEnvelopeVersion: {
         new (v0: number): {
             readonly tag: StorageError_Tags.UnsupportedEnvelopeVersion;
@@ -893,6 +1138,73 @@ export declare const StorageError: Readonly<{
             cause?: unknown;
         }): Readonly<[string]>;
     };
+    PersistentStorage: {
+        new (v0: string): {
+            readonly tag: StorageError_Tags.PersistentStorage;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: StorageError_Tags.PersistentStorage;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: StorageError_Tags.PersistentStorage;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: StorageError_Tags.PersistentStorage;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: StorageError_Tags.PersistentStorage;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+    };
     InvalidLeafIndex: {
         new (inner: {
             expected: bigint;
@@ -1367,6 +1679,140 @@ export declare const StorageError: Readonly<{
             keyPrefix: number;
         }>;
     };
+    ActivityDb: {
+        new (v0: string): {
+            readonly tag: StorageError_Tags.ActivityDb;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: StorageError_Tags.ActivityDb;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: StorageError_Tags.ActivityDb;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: StorageError_Tags.ActivityDb;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: StorageError_Tags.ActivityDb;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+    };
+    ActivityInvalidRecord: {
+        new (v0: string): {
+            readonly tag: StorageError_Tags.ActivityInvalidRecord;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: StorageError_Tags.ActivityInvalidRecord;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: StorageError_Tags.ActivityInvalidRecord;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: StorageError_Tags.ActivityInvalidRecord;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: StorageError_Tags.ActivityInvalidRecord;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "StorageError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+    };
     UnexpectedUniFfiCallbackError: {
         new (v0: string): {
             readonly tag: StorageError_Tags.UnexpectedUniFfiCallbackError;
@@ -1438,7 +1884,7 @@ export declare const StorageError: Readonly<{
 /**
  * Errors raised by credential storage primitives.
  */
-export type StorageError = InstanceType<(typeof StorageError)["Keystore" | "BlobStore" | "Lock" | "Serialization" | "Crypto" | "InvalidEnvelope" | "UnsupportedEnvelopeVersion" | "VaultDb" | "CacheDb" | "InvalidLeafIndex" | "CorruptedVault" | "NotInitialized" | "NullifierAlreadyDisclosed" | "CredentialNotFound" | "CredentialIdNotFound" | "CorruptedCacheEntry" | "UnexpectedUniFfiCallbackError"]>;
+export type StorageError = InstanceType<(typeof StorageError)["Keystore" | "BlobStore" | "Lock" | "Serialization" | "Crypto" | "InvalidEnvelope" | "InvalidInput" | "UnsupportedEnvelopeVersion" | "VaultDb" | "CacheDb" | "PersistentStorage" | "InvalidLeafIndex" | "CorruptedVault" | "NotInitialized" | "NullifierAlreadyDisclosed" | "CredentialNotFound" | "CredentialIdNotFound" | "CorruptedCacheEntry" | "ActivityDb" | "ActivityInvalidRecord" | "UnexpectedUniFfiCallbackError"]>;
 export declare enum CredentialConstraintsCheckError_Tags {
     Storage = "Storage",
     ConstraintTooDeep = "ConstraintTooDeep",
@@ -4616,9 +5062,11 @@ export interface AuthenticatorLike {
         signal: AbortSignal;
     }): Promise<RecoveryUpdateSignature>;
     /**
-     * Permanently destroys all credential storage data.
+     * Closes credential storage and attempts to delete its database files.
      *
-     * Removes the encryption keys, vault database, and cache database.
+     * Releases the store's key reference and removes the vault and cache databases
+     * on a best-effort basis. File deletion failures are logged, not returned.
+     * The host must separately delete any key envelope it owns.
      * After this call the authenticator can no longer generate proofs or
      * access stored credentials. Intended for logout or account deletion.
      *
@@ -4944,9 +5392,11 @@ export declare class Authenticator extends UniffiAbstractObject implements Authe
         signal: AbortSignal;
     }): Promise<RecoveryUpdateSignature>;
     /**
-     * Permanently destroys all credential storage data.
+     * Closes credential storage and attempts to delete its database files.
      *
-     * Removes the encryption keys, vault database, and cache database.
+     * Releases the store's key reference and removes the vault and cache databases
+     * on a best-effort basis. File deletion failures are logged, not returned.
+     * The host must separately delete any key envelope it owns.
      * After this call the authenticator can no longer generate proofs or
      * access stored credentials. Intended for logout or account deletion.
      *
@@ -5191,6 +5641,24 @@ export interface CredentialLike {
      * The commitment scheme is issuer-defined.
      */
     associatedDataCommitment(): FieldElementLike;
+    /**
+     * Returns the credential's raw claims, in schema order.
+     *
+     * Each claim is a field element; interpretation is defined by the issuer
+     * schema ([`Self::issuer_schema_id`]). Unset slots hold the zero field
+     * element. This exposes nothing [`Self::to_bytes`] doesn't already
+     * serialize — it is an accessor, not a disclosure mechanism; whether and
+     * which claims leave the device is entirely the host app's policy.
+     */
+    claims(): Array<FieldElementLike>;
+    /**
+     * Returns the credential's raw claims as hex-encoded, padded strings, in
+     * schema order.
+     *
+     * Convenience over [`Self::claims`] using the same encoding claims carry
+     * in credential JSON.
+     */
+    claimsHex(): Array<string>;
     /**
      * Returns the credential's expiration timestamp (unix seconds).
      */
@@ -5228,23 +5696,29 @@ export declare class Credential extends UniffiAbstractObject implements Credenti
      */
     static fromBytes(bytes: ArrayBuffer): CredentialLike;
     /**
-     * Deserializes a `Credential` from an issuer response shaped as
-     * `{ "credential": ... }`.
-     *
-     * Accepting the complete response lets JavaScript callers pass its raw
-     * bytes to Rust without parsing signed `u64` fields as lossy JS numbers.
+     * Returns the credential's `associated_data_commitment` field element.
      *
-     * # Errors
+     * The commitment scheme is issuer-defined.
+     */
+    associatedDataCommitment(): FieldElementLike;
+    /**
+     * Returns the credential's raw claims, in schema order.
      *
-     * Returns an error if the response or its credential cannot be deserialized.
+     * Each claim is a field element; interpretation is defined by the issuer
+     * schema ([`Self::issuer_schema_id`]). Unset slots hold the zero field
+     * element. This exposes nothing [`Self::to_bytes`] doesn't already
+     * serialize — it is an accessor, not a disclosure mechanism; whether and
+     * which claims leave the device is entirely the host app's policy.
      */
-    static fromIssuanceResponseBytes(bytes: ArrayBuffer): CredentialLike;
+    claims(): Array<FieldElementLike>;
     /**
-     * Returns the credential's `associated_data_commitment` field element.
+     * Returns the credential's raw claims as hex-encoded, padded strings, in
+     * schema order.
      *
-     * The commitment scheme is issuer-defined.
+     * Convenience over [`Self::claims`] using the same encoding claims carry
+     * in credential JSON.
      */
-    associatedDataCommitment(): FieldElementLike;
+    claimsHex(): Array<string>;
     /**
      * Returns the credential's expiration timestamp (unix seconds).
      */
@@ -5368,6 +5842,22 @@ export declare class StoragePaths extends UniffiAbstractObject implements Storag
  * Concrete storage implementation backed by `SQLCipher` databases.
  */
 export interface CredentialStoreLike {
+    /**
+     * Returns aggregate credential-activity metadata.
+     *
+     * # Errors
+     *
+     * Returns an error if the store is not initialized or the query fails.
+     */
+    activityMetadata(): ActivityMetadata;
+    /**
+     * Deletes all activity entries. Returns the number of entries deleted.
+     *
+     * # Errors
+     *
+     * Returns an error if the store is not initialized or the delete fails.
+     */
+    clearActivities(): bigint;
     /**
      * **Development only.** Permanently deletes all stored credentials and their
      * associated blob data from the vault.
@@ -5397,21 +5887,31 @@ export interface CredentialStoreLike {
      */
     deleteCredential(credentialId: bigint): void;
     /**
-     * Permanently destroys all credential storage data.
+     * Closes the databases, releases this store's key reference, and attempts file cleanup.
      *
-     * This removes the encryption key envelope, the vault database, and the
-     * cache database. After this call the store is left in an uninitialized
-     * state — any subsequent operation (other than re-initialization) will
-     * return [`StorageError::NotInitialized`].
+     * The host owns envelope deletion via `delete_storage_key_envelope`. This
+     * store cannot be reinitialized after destruction; construct a new store
+     * with resolved keys. Other key owners are unaffected.
+     * Database file deletion is best effort: failures are logged, not returned.
      *
-     * Intended for use when the user logs out or deletes their account.
+     * # Errors
+     * Returns an error if locking fails.
+     */
+    destroyStorage(): void;
+    /**
+     * Retrieves the most recent non-expired credential matching the issuer
+     * schema ID, or `None` when the store holds no usable match.
+     *
+     * This is the same selection `generate_proof` uses when building its
+     * credential inputs, so fields read from the returned credential (e.g.
+     * [`Credential::claims_hex`]) describe the credential a proof for that
+     * schema is generated against.
      *
      * # Errors
      *
-     * Returns an error if the storage lock cannot be acquired or the key
-     * envelope cannot be deleted from the blob store.
+     * Returns an error if the credential query fails.
      */
-    destroyStorage(): void;
+    fetchCredential(issuerSchemaId: bigint, now: bigint): CredentialLike | undefined;
     /**
      * Initializes storage and validates the account leaf index.
      *
@@ -5420,6 +5920,14 @@ export interface CredentialStoreLike {
      * Returns an error if initialization fails or the leaf index mismatches.
      */
     init(leafIndex: bigint, now: bigint): void;
+    /**
+     * Lists activity entries, most recent first.
+     *
+     * # Errors
+     *
+     * Returns an error if the store is not initialized or the query fails.
+     */
+    listActivities(query: ActivityQuery, limit: number, offset: number): Array<ActivityEntry>;
     /**
      * Lists credential metadata, optionally filtered by issuer schema ID.
      *
@@ -5431,6 +5939,14 @@ export interface CredentialStoreLike {
      * Returns an error if the credential query fails.
      */
     listCredentials(issuerSchemaId: bigint | undefined, now: bigint): Array<CredentialRecord>;
+    /**
+     * Records a new activity entry.
+     *
+     * # Errors
+     *
+     * Returns an error if the store is not initialized or the query fails.
+     */
+    recordActivity(entry: ActivityEntry, now: bigint): bigint;
     /**
      * Returns the storage paths used by this handle.
      *
@@ -5459,35 +5975,33 @@ export declare class CredentialStore extends UniffiAbstractObject implements Cre
     readonly [uniffiTypeNameSymbol] = "CredentialStore";
     readonly [destructorGuardSymbol]: UniffiGcObject;
     readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
     /**
-     * Creates a new storage handle from a platform provider.
+     * Creates storage from paths and an already-resolved database key.
      *
-     * # Errors
+     * The store retains the keys through initialization retries and releases
+     * its reference on destruction. Callers should release their own key handles
+     * once construction succeeds.
      *
+     * # Errors
      * Returns an error if the storage lock cannot be opened.
      */
-    static fromProviderArc(provider: StorageProvider): CredentialStoreLike;
+    constructor(paths: StoragePathsLike, keys: StorageKeysLike);
     /**
-     * Creates process-local credential storage for browser demos and tests.
-     *
-     * The store is discarded when the page is refreshed. Its key envelope is
-     * kept in memory without device-bound encryption, so callers must not use
-     * this constructor for production credentials.
+     * Returns aggregate credential-activity metadata.
      *
      * # Errors
      *
-     * Returns an error if the in-memory storage handle cannot be created.
+     * Returns an error if the store is not initialized or the query fails.
      */
-    static newEphemeral(): CredentialStoreLike;
+    activityMetadata(): ActivityMetadata;
     /**
-     * Creates a new storage handle from explicit components.
+     * Deletes all activity entries. Returns the number of entries deleted.
      *
      * # Errors
      *
-     * Returns an error if the storage lock cannot be opened.
+     * Returns an error if the store is not initialized or the delete fails.
      */
-    static newWithComponents(paths: StoragePathsLike, keystore: DeviceKeystore, blobStore: AtomicBlobStore): CredentialStoreLike;
+    clearActivities(): bigint;
     /**
      * **Development only.** Permanently deletes all stored credentials and their
      * associated blob data from the vault.
@@ -5517,21 +6031,31 @@ export declare class CredentialStore extends UniffiAbstractObject implements Cre
      */
     deleteCredential(credentialId: bigint): void;
     /**
-     * Permanently destroys all credential storage data.
+     * Closes the databases, releases this store's key reference, and attempts file cleanup.
      *
-     * This removes the encryption key envelope, the vault database, and the
-     * cache database. After this call the store is left in an uninitialized
-     * state — any subsequent operation (other than re-initialization) will
-     * return [`StorageError::NotInitialized`].
+     * The host owns envelope deletion via `delete_storage_key_envelope`. This
+     * store cannot be reinitialized after destruction; construct a new store
+     * with resolved keys. Other key owners are unaffected.
+     * Database file deletion is best effort: failures are logged, not returned.
      *
-     * Intended for use when the user logs out or deletes their account.
+     * # Errors
+     * Returns an error if locking fails.
+     */
+    destroyStorage(): void;
+    /**
+     * Retrieves the most recent non-expired credential matching the issuer
+     * schema ID, or `None` when the store holds no usable match.
+     *
+     * This is the same selection `generate_proof` uses when building its
+     * credential inputs, so fields read from the returned credential (e.g.
+     * [`Credential::claims_hex`]) describe the credential a proof for that
+     * schema is generated against.
      *
      * # Errors
      *
-     * Returns an error if the storage lock cannot be acquired or the key
-     * envelope cannot be deleted from the blob store.
+     * Returns an error if the credential query fails.
      */
-    destroyStorage(): void;
+    fetchCredential(issuerSchemaId: bigint, now: bigint): CredentialLike | undefined;
     /**
      * Initializes storage and validates the account leaf index.
      *
@@ -5540,6 +6064,14 @@ export declare class CredentialStore extends UniffiAbstractObject implements Cre
      * Returns an error if initialization fails or the leaf index mismatches.
      */
     init(leafIndex: bigint, now: bigint): void;
+    /**
+     * Lists activity entries, most recent first.
+     *
+     * # Errors
+     *
+     * Returns an error if the store is not initialized or the query fails.
+     */
+    listActivities(query: ActivityQuery, limit: number, offset: number): Array<ActivityEntry>;
     /**
      * Lists credential metadata, optionally filtered by issuer schema ID.
      *
@@ -5551,6 +6083,14 @@ export declare class CredentialStore extends UniffiAbstractObject implements Cre
      * Returns an error if the credential query fails.
      */
     listCredentials(issuerSchemaId: bigint | undefined, now: bigint): Array<CredentialRecord>;
+    /**
+     * Records a new activity entry.
+     *
+     * # Errors
+     *
+     * Returns an error if the store is not initialized or the query fails.
+     */
+    recordActivity(entry: ActivityEntry, now: bigint): bigint;
     /**
      * Returns the storage paths used by this handle.
      *
@@ -5889,6 +6429,37 @@ export declare class LoggerImpl extends UniffiAbstractObject implements Logger {
     uniffiDestroy(): void;
     static instanceOf(obj_: any): obj_ is LoggerImpl;
 }
+/**
+ * Resolved in-memory database keys, independent of their source.
+ *
+ * Keys are zeroized when the last owner drops this object.
+ */
+export interface StorageKeysLike {
+}
+/**
+ * @deprecated Use `StorageKeysLike` instead.
+ */
+export type StorageKeysInterface = StorageKeysLike;
+/**
+ * Resolved in-memory database keys, independent of their source.
+ *
+ * Keys are zeroized when the last owner drops this object.
+ */
+export declare class StorageKeys extends UniffiAbstractObject implements StorageKeysLike {
+    readonly [uniffiTypeNameSymbol] = "StorageKeys";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    /**
+     * Takes a resolved 32-byte database key, for example derived from a passkey PRF.
+     *
+     * # Errors
+     * Returns an error if the key is not exactly 32 bytes.
+     */
+    static fromBytes(databaseKey: ArrayBuffer): StorageKeysLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is StorageKeys;
+}
 /**
  * Provider responsible for platform-specific storage components and paths.
  */
@@ -6048,6 +6619,41 @@ declare function uniffiEnsureInitialized(): void;
 declare const _default: Readonly<{
     initialize: typeof uniffiEnsureInitialized;
     converters: {
+        FfiConverterTypeActivityEntry: {
+            readFromCursor(c: Cursor): ActivityEntry;
+            writeIntoCursor(value: ActivityEntry, c: Cursor): void;
+            allocationSize(value: ActivityEntry): number;
+            lift(value: UniffiByteArray): ActivityEntry;
+            lower(value: ActivityEntry, alloc: RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActivityFailureReason: {
+            readFromCursor(c: Cursor): ActivityFailureReason;
+            writeIntoCursor(value: ActivityFailureReason, c: Cursor): void;
+            allocationSize(value: ActivityFailureReason): number;
+            lift(value: UniffiByteArray): ActivityFailureReason;
+            lower(value: ActivityFailureReason, alloc: RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActivityMetadata: {
+            readFromCursor(c: Cursor): ActivityMetadata;
+            writeIntoCursor(value: ActivityMetadata, c: Cursor): void;
+            allocationSize(value: ActivityMetadata): number;
+            lift(value: UniffiByteArray): ActivityMetadata;
+            lower(value: ActivityMetadata, alloc: RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActivityOutcome: {
+            readFromCursor(c: Cursor): ActivityOutcome;
+            writeIntoCursor(value: ActivityOutcome, c: Cursor): void;
+            allocationSize(value: ActivityOutcome): number;
+            lift(value: UniffiByteArray): ActivityOutcome;
+            lower(value: ActivityOutcome, alloc: RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActivityQuery: {
+            readFromCursor(c: Cursor): ActivityQuery;
+            writeIntoCursor(value: ActivityQuery, c: Cursor): void;
+            allocationSize(value: ActivityQuery): number;
+            lift(value: UniffiByteArray): ActivityQuery;
+            lower(value: ActivityQuery, alloc: RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeAtomicBlobStore: FfiConverterObjectWithCallbacks<AtomicBlobStore>;
         FfiConverterTypeAuthenticator: FfiConverterObject<AuthenticatorLike>;
         FfiConverterTypeBlobKind: {
@@ -6116,6 +6722,13 @@ declare const _default: Readonly<{
         FfiConverterTypeOwnershipProof: FfiConverterObject<OwnershipProofLike>;
         FfiConverterTypeProofRequest: FfiConverterObject<ProofRequestLike>;
         FfiConverterTypeProofResponse: FfiConverterObject<ProofResponseLike>;
+        FfiConverterTypeProtocolVersion: {
+            readFromCursor(c: Cursor): ProtocolVersion;
+            writeIntoCursor(value: ProtocolVersion, c: Cursor): void;
+            allocationSize(value: ProtocolVersion): number;
+            lift(value: UniffiByteArray): ProtocolVersion;
+            lower(value: ProtocolVersion, alloc: RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeRecoveryData: {
             readFromCursor(c: Cursor): RecoveryData;
             writeIntoCursor(value: RecoveryData, c: Cursor): void;
@@ -6165,6 +6778,7 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): StorageError;
             lower(value: StorageError, alloc: RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeStorageKeys: FfiConverterObject<StorageKeysLike>;
         FfiConverterTypeStoragePaths: FfiConverterObject<StoragePathsLike>;
         FfiConverterTypeStorageProvider: FfiConverterObjectWithCallbacks<StorageProvider>;
         FfiConverterTypeUint256: FfiConverter<UniffiByteArray, string>;