@orbinum/sdk 0.25.0 → 1.0.0

package/dist/secretStore-CF6Nse__.d.mts

@@ -0,0 +1,292 @@
+/**
+ * The shape a note takes at rest.
+ *
+ * Any backend — IndexedDB, SQLite, remote — produces and consumes exactly this,
+ * so `encryptNote` / `decryptNoteRecord` work against all of them unmodified.
+ */
+/**
+ * One encrypted note as stored.
+ *
+ * Identifiers are BLINDED: stored as HMAC tags under the vault blind key, never
+ * the raw on-chain hex. A storage dump therefore reveals no commitment,
+ * nullifier or asset that could be linked to chain activity, while equality
+ * lookups still work by comparing tags.
+ *
+ * `spent` / `spentAt` stay plaintext deliberately — they are local flags with
+ * no on-chain linkage, and keeping them readable lets a backend filter spent
+ * notes without unlocking the vault.
+ */
+interface EncryptedNoteRecord {
+    /** Primary key — blinded commitment tag: HMAC(blindKey, commitmentHex). */
+    commitmentTag: string;
+    /** AES-GCM IV for this record — base64 */
+    iv: string;
+    /** AES-GCM ciphertext of the full ZkNote JSON — base64 */
+    ciphertext: string;
+    /** Blinded nullifier tag: HMAC(blindKey, nullifierHex). Quick spent-check. */
+    nullifierTag: string;
+    /** Blinded asset tag: HMAC(blindKey, assetId). Filter by asset without unlock. */
+    assetTag: string;
+    /** Whether the note has already been spent/nullified on-chain. */
+    spent?: boolean;
+    /** When the app marked the note as spent locally, if known. */
+    spentAt?: number | null;
+    updatedAt: number;
+}
+/** Partial update applied to a note's spent status without re-encrypting the full payload. */
+interface NoteStatusUpdate {
+    spent?: boolean;
+    spentAt?: number | null;
+}
+
+/**
+ * The persistence contract a wallet's vault runs on.
+ *
+ * Split by responsibility rather than exposed as one interface: a consumer that
+ * only decrypts notes never has to supply a nullifier cache, and an
+ * implementation can grow one concern at a time. `VaultStorage` composes the
+ * three for the common case.
+ *
+ * Every method is async because the reference backend is IndexedDB. Records
+ * cross this boundary already encrypted and with identifiers blinded (see
+ * `EncryptedNoteRecord`), so a backend never sees a commitment, a nullifier, or
+ * an amount — which is what makes an untrusted or remote backend viable.
+ */
+
+/** Wallet-level state that is not a note: cursors and ephemeral-key counters. */
+interface VaultConfigRecord {
+    id: 'main';
+    /** Schema version of this record's shape. */
+    v: number;
+    /** Genesis hash the vault was last reconciled against. */
+    chainFingerprint?: string;
+    /** Highest leafIndex a completed scan processed; the next one resumes after it. */
+    lastScannedLeafIndex?: number;
+    /**
+     * Next self-note ephemeral index.
+     *
+     * Monotonic, and that is a protocol requirement rather than bookkeeping:
+     * reusing an index republishes the same ephPk and publicly links the two
+     * notes as sharing a creator.
+     */
+    selfEphCounter?: number;
+    /**
+     * Counterparties whose payments can be recognised without a trial ECDH,
+     * keyed by their packed viewing public key (lowercase hex). Each carries its
+     * own counter, monotonic for the same reason as `selfEphCounter`.
+     */
+    pairwiseCounterparties?: Record<string, {
+        nextIndex: number;
+        addedAt: number;
+    }>;
+    createdAt: number;
+    updatedAt: number;
+}
+/** An encrypted entry in the local transaction history. */
+interface EncryptedTxRecord {
+    /** Primary key — the transaction hash, the one field left in plaintext. */
+    id: string;
+    /** AES-GCM IV, base64. */
+    iv: string;
+    /** AES-GCM ciphertext of the record body, base64. */
+    ciphertext: string;
+    updatedAt: number;
+}
+/**
+ * What is known locally about a spend, once a nullifier turns up in the set.
+ *
+ * Both fields are public chain data recovered from a set that always transfers
+ * whole — neither implies a per-nullifier query.
+ */
+interface SpendDetails {
+    /** Spend block timestamp (ms); null when the source carried none. */
+    spentAt: number | null;
+    /** Hash of the spending transaction; null when the extrinsic was unresolvable. */
+    txHash: string | null;
+}
+/**
+ * One entry of the spent-nullifier set, stored as it arrives.
+ *
+ * Field names are terse because there is one record per spent note on the
+ * chain: at millions of notes the key strings are a material share of the
+ * cache's size on disk.
+ */
+interface CachedNullifier {
+    /** The nullifier hex, as the source publishes it. Primary key. */
+    h: string;
+    /** Spend block timestamp (ms); null when the source carried none. */
+    ts: number | null;
+    /** Hash of the spending transaction; null when unresolvable. */
+    tx?: string | null;
+}
+/** Progress of the nullifier-set download, so a sync resumes instead of restarting. */
+interface NullifierSyncMeta {
+    id: 'main';
+    /** Sealed chunks already stored. */
+    chunksDone: number;
+    /** Generation of the set the stored chunks belong to; a change invalidates them. */
+    generation: string;
+    totalStored: number;
+    updatedAt: number;
+}
+/** Config and note persistence — the minimum a wallet needs to hold funds. */
+interface NoteStorage {
+    getConfig(): Promise<VaultConfigRecord | null>;
+    putConfig(config: VaultConfigRecord): Promise<void>;
+    /**
+     * Applies `mutate` to the stored config as ONE atomic read-modify-write.
+     *
+     * Part of the contract, not sugar over get + put. Two concurrent callers
+     * doing that separately both read the same `selfEphCounter`, so both derive
+     * the same ephemeral index and publish the same ephPk — a privacy leak, not
+     * a lost update. A backend that cannot make this atomic cannot host a vault.
+     *
+     * Resolves to null when no config exists; `mutate` is not called.
+     */
+    updateConfig(mutate: (config: VaultConfigRecord) => VaultConfigRecord): Promise<VaultConfigRecord | null>;
+    getAllNoteRecords(): Promise<EncryptedNoteRecord[]>;
+    putNote(record: EncryptedNoteRecord): Promise<void>;
+    putNotes(records: EncryptedNoteRecord[]): Promise<void>;
+    deleteNote(commitmentTag: string): Promise<void>;
+    deleteNotes(commitmentTags: string[]): Promise<void>;
+    clearNotes(): Promise<void>;
+}
+/**
+ * Local mirror of the spent-nullifier set.
+ *
+ * The whole set is downloaded and intersected locally, deliberately: asking a
+ * server whether one specific nullifier is spent would tell it which notes the
+ * wallet holds. That is why this is a cache to fill, not a lookup to call.
+ */
+interface NullifierCache {
+    /**
+     * Stores one sealed chunk together with the sync progress it produced.
+     *
+     * Both must land in the same transaction: progress ahead of the data would
+     * make the next sync resume past chunks the cache never stored, leaving
+     * spent notes looking unspent.
+     */
+    putNullifierChunk(entries: CachedNullifier[], meta: NullifierSyncMeta): Promise<void>;
+    getNullifierSyncMeta(): Promise<NullifierSyncMeta | null>;
+    /**
+     * Which of `hexes` the cache holds. Absent keys are unspent as far as it
+     * knows.
+     *
+     * Matching is EXACT: a backend must not lowercase, trim or otherwise repair
+     * a key. Normalising happens once at ingestion, where the feed's rows are
+     * lowercased on the way into `putNullifierChunk` — so everything stored is
+     * already in one form, and a backend that "helpfully" normalised again
+     * would only hide a caller passing the wrong case.
+     *
+     * Both sides must agree, and the cost of disagreeing is not a missing row:
+     * a lookup that misses reports a SPENT note as unspent, the wallet offers
+     * it, and the spend dies on a duplicate nullifier.
+     */
+    getSpentNullifiers(hexes: string[]): Promise<Map<string, SpendDetails>>;
+    countNullifiers(): Promise<number>;
+    clearNullifierCache(): Promise<void>;
+}
+/** Encrypted local transaction history — outgoing sends the chain cannot reveal. */
+interface TxHistoryStore {
+    addTxRecord(record: EncryptedTxRecord): Promise<void>;
+    getAllTxRecords(): Promise<EncryptedTxRecord[]>;
+}
+/** Everything a full wallet needs from persistence. */
+interface VaultStorage extends NoteStorage, NullifierCache, TxHistoryStore {
+    /** Whether a vault already exists for this identity. */
+    hasVault(): Promise<boolean>;
+}
+
+/**
+ * The key that protects secrets at rest on one device.
+ *
+ * A single AES-GCM-256 key, generated once and kept for the life of the install.
+ * Where the platform allows it the key must be NON-EXTRACTABLE — created with
+ * `extractable: false` and persisted as a key handle rather than as bytes — so
+ * a storage dump, disk image or synced profile yields nothing usable.
+ *
+ * ## Why not derive it from the wallet signature
+ *
+ * Circular. The thing being protected is the cached identity, and the reason it
+ * is cached is to avoid asking for a signature again. A key derived from that
+ * signature would require the signature to read the cache that exists to avoid
+ * the signature.
+ *
+ * ## Platform notes
+ *
+ * Browsers and extensions: `@orbinum/sdk/storage/indexeddb` exports
+ * `getOrCreateIndexedDbDeviceKey`, which stores a non-extractable `CryptoKey`
+ * via structured clone — the key material never becomes visible to JavaScript.
+ *
+ * React Native and Node: no non-extractable handle survives a restart, so store
+ * raw key bytes in the platform's secure enclave (Keychain, Keystore) and import
+ * them with `importDeviceKey`. The isolation then comes from the enclave rather
+ * than from the key being unexportable.
+ */
+/**
+ * A fresh AES-GCM-256 device key.
+ *
+ * `extractable` defaults to false and should stay that way. Passing true is for
+ * the platforms described above — the ones that cannot persist a key handle and
+ * must export raw bytes into a secure enclave. Anywhere a handle survives a
+ * restart, an extractable key is strictly worse: the material becomes readable
+ * by any code in the context.
+ */
+declare function generateDeviceKey(extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Imports raw device-key bytes, for platforms that persist bytes in a secure
+ * enclave rather than a key handle. The imported key is non-extractable, so the
+ * bytes cannot be read back out through WebCrypto.
+ */
+declare function importDeviceKey(raw: Uint8Array): Promise<CryptoKey>;
+/**
+ * Where a device key is persisted between launches.
+ *
+ * `load` returning null means "no key yet", not "failed" — the provider takes
+ * that as permission to generate one. An adapter that cannot reach its backend
+ * should throw instead, or the first transient failure silently mints a second
+ * key and orphans every secret encrypted under the first.
+ */
+interface DeviceKeyStore {
+    load(): Promise<CryptoKey | null>;
+    save(key: CryptoKey): Promise<void>;
+}
+/**
+ * The device key, generating and persisting it on first use.
+ *
+ * Cached in memory per process: generating a second key would silently orphan
+ * every secret encrypted under the first.
+ */
+declare function createDeviceKeyProvider(store: DeviceKeyStore): () => Promise<CryptoKey>;
+
+/**
+ * Where a host keeps small secrets between sessions.
+ *
+ * Three methods, because that is all the identity cache needs and every platform
+ * has them: `localStorage` in a page, `chrome.storage.local` in an extension,
+ * Keychain or SharedPreferences on mobile, a file on a server. Keeping the
+ * surface this small is what makes those adapters a few lines each.
+ *
+ * Values handed to `set` are already ENCRYPTED — see `sessionCache`. A store is
+ * not trusted with plaintext secrets, so a backend with weak isolation is still
+ * a safe place to put one.
+ */
+interface SecretStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    /**
+     * Keys currently held. Needed to clear every network's cache for one account
+     * on disconnect, which cannot be done by constructing keys — the caller does
+     * not know which chains the user has visited.
+     */
+    keys(): Promise<string[]>;
+}
+/**
+ * An in-memory `SecretStore`. Loses everything on restart, which is the whole
+ * point of the real ones — useful for tests and for a host that deliberately
+ * wants re-signing on every launch.
+ */
+declare function createMemorySecretStore(): SecretStore;
+
+export { type CachedNullifier as C, type DeviceKeyStore as D, type EncryptedNoteRecord as E, type NullifierSyncMeta as N, type SpendDetails as S, type TxHistoryStore as T, type VaultStorage as V, type VaultConfigRecord as a, type EncryptedTxRecord as b, type SecretStore as c, type NoteStorage as d, type NoteStatusUpdate as e, type NullifierCache as f, createDeviceKeyProvider as g, createMemorySecretStore as h, generateDeviceKey as i, importDeviceKey as j };

package/dist/secretStore-CF6Nse__.d.ts

@@ -0,0 +1,292 @@
+/**
+ * The shape a note takes at rest.
+ *
+ * Any backend — IndexedDB, SQLite, remote — produces and consumes exactly this,
+ * so `encryptNote` / `decryptNoteRecord` work against all of them unmodified.
+ */
+/**
+ * One encrypted note as stored.
+ *
+ * Identifiers are BLINDED: stored as HMAC tags under the vault blind key, never
+ * the raw on-chain hex. A storage dump therefore reveals no commitment,
+ * nullifier or asset that could be linked to chain activity, while equality
+ * lookups still work by comparing tags.
+ *
+ * `spent` / `spentAt` stay plaintext deliberately — they are local flags with
+ * no on-chain linkage, and keeping them readable lets a backend filter spent
+ * notes without unlocking the vault.
+ */
+interface EncryptedNoteRecord {
+    /** Primary key — blinded commitment tag: HMAC(blindKey, commitmentHex). */
+    commitmentTag: string;
+    /** AES-GCM IV for this record — base64 */
+    iv: string;
+    /** AES-GCM ciphertext of the full ZkNote JSON — base64 */
+    ciphertext: string;
+    /** Blinded nullifier tag: HMAC(blindKey, nullifierHex). Quick spent-check. */
+    nullifierTag: string;
+    /** Blinded asset tag: HMAC(blindKey, assetId). Filter by asset without unlock. */
+    assetTag: string;
+    /** Whether the note has already been spent/nullified on-chain. */
+    spent?: boolean;
+    /** When the app marked the note as spent locally, if known. */
+    spentAt?: number | null;
+    updatedAt: number;
+}
+/** Partial update applied to a note's spent status without re-encrypting the full payload. */
+interface NoteStatusUpdate {
+    spent?: boolean;
+    spentAt?: number | null;
+}
+
+/**
+ * The persistence contract a wallet's vault runs on.
+ *
+ * Split by responsibility rather than exposed as one interface: a consumer that
+ * only decrypts notes never has to supply a nullifier cache, and an
+ * implementation can grow one concern at a time. `VaultStorage` composes the
+ * three for the common case.
+ *
+ * Every method is async because the reference backend is IndexedDB. Records
+ * cross this boundary already encrypted and with identifiers blinded (see
+ * `EncryptedNoteRecord`), so a backend never sees a commitment, a nullifier, or
+ * an amount — which is what makes an untrusted or remote backend viable.
+ */
+
+/** Wallet-level state that is not a note: cursors and ephemeral-key counters. */
+interface VaultConfigRecord {
+    id: 'main';
+    /** Schema version of this record's shape. */
+    v: number;
+    /** Genesis hash the vault was last reconciled against. */
+    chainFingerprint?: string;
+    /** Highest leafIndex a completed scan processed; the next one resumes after it. */
+    lastScannedLeafIndex?: number;
+    /**
+     * Next self-note ephemeral index.
+     *
+     * Monotonic, and that is a protocol requirement rather than bookkeeping:
+     * reusing an index republishes the same ephPk and publicly links the two
+     * notes as sharing a creator.
+     */
+    selfEphCounter?: number;
+    /**
+     * Counterparties whose payments can be recognised without a trial ECDH,
+     * keyed by their packed viewing public key (lowercase hex). Each carries its
+     * own counter, monotonic for the same reason as `selfEphCounter`.
+     */
+    pairwiseCounterparties?: Record<string, {
+        nextIndex: number;
+        addedAt: number;
+    }>;
+    createdAt: number;
+    updatedAt: number;
+}
+/** An encrypted entry in the local transaction history. */
+interface EncryptedTxRecord {
+    /** Primary key — the transaction hash, the one field left in plaintext. */
+    id: string;
+    /** AES-GCM IV, base64. */
+    iv: string;
+    /** AES-GCM ciphertext of the record body, base64. */
+    ciphertext: string;
+    updatedAt: number;
+}
+/**
+ * What is known locally about a spend, once a nullifier turns up in the set.
+ *
+ * Both fields are public chain data recovered from a set that always transfers
+ * whole — neither implies a per-nullifier query.
+ */
+interface SpendDetails {
+    /** Spend block timestamp (ms); null when the source carried none. */
+    spentAt: number | null;
+    /** Hash of the spending transaction; null when the extrinsic was unresolvable. */
+    txHash: string | null;
+}
+/**
+ * One entry of the spent-nullifier set, stored as it arrives.
+ *
+ * Field names are terse because there is one record per spent note on the
+ * chain: at millions of notes the key strings are a material share of the
+ * cache's size on disk.
+ */
+interface CachedNullifier {
+    /** The nullifier hex, as the source publishes it. Primary key. */
+    h: string;
+    /** Spend block timestamp (ms); null when the source carried none. */
+    ts: number | null;
+    /** Hash of the spending transaction; null when unresolvable. */
+    tx?: string | null;
+}
+/** Progress of the nullifier-set download, so a sync resumes instead of restarting. */
+interface NullifierSyncMeta {
+    id: 'main';
+    /** Sealed chunks already stored. */
+    chunksDone: number;
+    /** Generation of the set the stored chunks belong to; a change invalidates them. */
+    generation: string;
+    totalStored: number;
+    updatedAt: number;
+}
+/** Config and note persistence — the minimum a wallet needs to hold funds. */
+interface NoteStorage {
+    getConfig(): Promise<VaultConfigRecord | null>;
+    putConfig(config: VaultConfigRecord): Promise<void>;
+    /**
+     * Applies `mutate` to the stored config as ONE atomic read-modify-write.
+     *
+     * Part of the contract, not sugar over get + put. Two concurrent callers
+     * doing that separately both read the same `selfEphCounter`, so both derive
+     * the same ephemeral index and publish the same ephPk — a privacy leak, not
+     * a lost update. A backend that cannot make this atomic cannot host a vault.
+     *
+     * Resolves to null when no config exists; `mutate` is not called.
+     */
+    updateConfig(mutate: (config: VaultConfigRecord) => VaultConfigRecord): Promise<VaultConfigRecord | null>;
+    getAllNoteRecords(): Promise<EncryptedNoteRecord[]>;
+    putNote(record: EncryptedNoteRecord): Promise<void>;
+    putNotes(records: EncryptedNoteRecord[]): Promise<void>;
+    deleteNote(commitmentTag: string): Promise<void>;
+    deleteNotes(commitmentTags: string[]): Promise<void>;
+    clearNotes(): Promise<void>;
+}
+/**
+ * Local mirror of the spent-nullifier set.
+ *
+ * The whole set is downloaded and intersected locally, deliberately: asking a
+ * server whether one specific nullifier is spent would tell it which notes the
+ * wallet holds. That is why this is a cache to fill, not a lookup to call.
+ */
+interface NullifierCache {
+    /**
+     * Stores one sealed chunk together with the sync progress it produced.
+     *
+     * Both must land in the same transaction: progress ahead of the data would
+     * make the next sync resume past chunks the cache never stored, leaving
+     * spent notes looking unspent.
+     */
+    putNullifierChunk(entries: CachedNullifier[], meta: NullifierSyncMeta): Promise<void>;
+    getNullifierSyncMeta(): Promise<NullifierSyncMeta | null>;
+    /**
+     * Which of `hexes` the cache holds. Absent keys are unspent as far as it
+     * knows.
+     *
+     * Matching is EXACT: a backend must not lowercase, trim or otherwise repair
+     * a key. Normalising happens once at ingestion, where the feed's rows are
+     * lowercased on the way into `putNullifierChunk` — so everything stored is
+     * already in one form, and a backend that "helpfully" normalised again
+     * would only hide a caller passing the wrong case.
+     *
+     * Both sides must agree, and the cost of disagreeing is not a missing row:
+     * a lookup that misses reports a SPENT note as unspent, the wallet offers
+     * it, and the spend dies on a duplicate nullifier.
+     */
+    getSpentNullifiers(hexes: string[]): Promise<Map<string, SpendDetails>>;
+    countNullifiers(): Promise<number>;
+    clearNullifierCache(): Promise<void>;
+}
+/** Encrypted local transaction history — outgoing sends the chain cannot reveal. */
+interface TxHistoryStore {
+    addTxRecord(record: EncryptedTxRecord): Promise<void>;
+    getAllTxRecords(): Promise<EncryptedTxRecord[]>;
+}
+/** Everything a full wallet needs from persistence. */
+interface VaultStorage extends NoteStorage, NullifierCache, TxHistoryStore {
+    /** Whether a vault already exists for this identity. */
+    hasVault(): Promise<boolean>;
+}
+
+/**
+ * The key that protects secrets at rest on one device.
+ *
+ * A single AES-GCM-256 key, generated once and kept for the life of the install.
+ * Where the platform allows it the key must be NON-EXTRACTABLE — created with
+ * `extractable: false` and persisted as a key handle rather than as bytes — so
+ * a storage dump, disk image or synced profile yields nothing usable.
+ *
+ * ## Why not derive it from the wallet signature
+ *
+ * Circular. The thing being protected is the cached identity, and the reason it
+ * is cached is to avoid asking for a signature again. A key derived from that
+ * signature would require the signature to read the cache that exists to avoid
+ * the signature.
+ *
+ * ## Platform notes
+ *
+ * Browsers and extensions: `@orbinum/sdk/storage/indexeddb` exports
+ * `getOrCreateIndexedDbDeviceKey`, which stores a non-extractable `CryptoKey`
+ * via structured clone — the key material never becomes visible to JavaScript.
+ *
+ * React Native and Node: no non-extractable handle survives a restart, so store
+ * raw key bytes in the platform's secure enclave (Keychain, Keystore) and import
+ * them with `importDeviceKey`. The isolation then comes from the enclave rather
+ * than from the key being unexportable.
+ */
+/**
+ * A fresh AES-GCM-256 device key.
+ *
+ * `extractable` defaults to false and should stay that way. Passing true is for
+ * the platforms described above — the ones that cannot persist a key handle and
+ * must export raw bytes into a secure enclave. Anywhere a handle survives a
+ * restart, an extractable key is strictly worse: the material becomes readable
+ * by any code in the context.
+ */
+declare function generateDeviceKey(extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Imports raw device-key bytes, for platforms that persist bytes in a secure
+ * enclave rather than a key handle. The imported key is non-extractable, so the
+ * bytes cannot be read back out through WebCrypto.
+ */
+declare function importDeviceKey(raw: Uint8Array): Promise<CryptoKey>;
+/**
+ * Where a device key is persisted between launches.
+ *
+ * `load` returning null means "no key yet", not "failed" — the provider takes
+ * that as permission to generate one. An adapter that cannot reach its backend
+ * should throw instead, or the first transient failure silently mints a second
+ * key and orphans every secret encrypted under the first.
+ */
+interface DeviceKeyStore {
+    load(): Promise<CryptoKey | null>;
+    save(key: CryptoKey): Promise<void>;
+}
+/**
+ * The device key, generating and persisting it on first use.
+ *
+ * Cached in memory per process: generating a second key would silently orphan
+ * every secret encrypted under the first.
+ */
+declare function createDeviceKeyProvider(store: DeviceKeyStore): () => Promise<CryptoKey>;
+
+/**
+ * Where a host keeps small secrets between sessions.
+ *
+ * Three methods, because that is all the identity cache needs and every platform
+ * has them: `localStorage` in a page, `chrome.storage.local` in an extension,
+ * Keychain or SharedPreferences on mobile, a file on a server. Keeping the
+ * surface this small is what makes those adapters a few lines each.
+ *
+ * Values handed to `set` are already ENCRYPTED — see `sessionCache`. A store is
+ * not trusted with plaintext secrets, so a backend with weak isolation is still
+ * a safe place to put one.
+ */
+interface SecretStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    /**
+     * Keys currently held. Needed to clear every network's cache for one account
+     * on disconnect, which cannot be done by constructing keys — the caller does
+     * not know which chains the user has visited.
+     */
+    keys(): Promise<string[]>;
+}
+/**
+ * An in-memory `SecretStore`. Loses everything on restart, which is the whole
+ * point of the real ones — useful for tests and for a host that deliberately
+ * wants re-signing on every launch.
+ */
+declare function createMemorySecretStore(): SecretStore;
+
+export { type CachedNullifier as C, type DeviceKeyStore as D, type EncryptedNoteRecord as E, type NullifierSyncMeta as N, type SpendDetails as S, type TxHistoryStore as T, type VaultStorage as V, type VaultConfigRecord as a, type EncryptedTxRecord as b, type SecretStore as c, type NoteStorage as d, type NoteStatusUpdate as e, type NullifierCache as f, createDeviceKeyProvider as g, createMemorySecretStore as h, generateDeviceKey as i, importDeviceKey as j };

package/dist/wallet/worker/index.d.mts

@@ -0,0 +1 @@
+export { c as DECRYPT_YIELD_EVERY, d as DecryptBatchResult, a as DecryptPool, e as DecryptRequest, E as EMPTY_BATCH_RESULT, K as KnownEphEntry, f as KnownEphWindow, M as MAX_WORKERS, g as MatchSource, P as PAIRWISE_EPH_WINDOW, i as SELF_EPH_WINDOW, b as ScanKeys, W as WORKER_CRASHED, j as WorkerFactory, k as WorkerLike, l as WorkerMessage, m as clearKnownEphWindow, n as createDecryptPool, o as createMainThreadPool, p as createWorkerPool, q as decryptHintBatch, r as getKnownEphWindow } from '../../index-JYVjYJtf.mjs';

package/dist/wallet/worker/index.d.ts

@@ -0,0 +1 @@
+export { c as DECRYPT_YIELD_EVERY, d as DecryptBatchResult, a as DecryptPool, e as DecryptRequest, E as EMPTY_BATCH_RESULT, K as KnownEphEntry, f as KnownEphWindow, M as MAX_WORKERS, g as MatchSource, P as PAIRWISE_EPH_WINDOW, i as SELF_EPH_WINDOW, b as ScanKeys, W as WORKER_CRASHED, j as WorkerFactory, k as WorkerLike, l as WorkerMessage, m as clearKnownEphWindow, n as createDecryptPool, o as createMainThreadPool, p as createWorkerPool, q as decryptHintBatch, r as getKnownEphWindow } from '../../index-JYVjYJtf.js';