@unlink-xyz/core 0.1.0

package/dist/state/store/nullifier-store.js

@@ -0,0 +1,30 @@
+import { keys } from "../../keys.js";
+import { getJson, putJson } from "../../utils/json-codec.js";
+import { ensureChainId } from "../../utils/validators.js";
+export function createNullifierStore(storage) {
+    return {
+        /**
+         * Record a nullifier observation so later syncs can de-duplicate work.
+         */
+        async putNullifier(nullifier) {
+            ensureChainId(nullifier.chainId);
+            await putJson(storage, keys.nullifier(nullifier.chainId, nullifier.nullifier), nullifier);
+        },
+        /**
+         * Lookup a previously observed nullifier by value.
+         */
+        async getNullifier(chainId, value) {
+            ensureChainId(chainId);
+            return getJson(storage, keys.nullifier(chainId, value));
+        },
+        /**
+         * Count all nullifiers stored locally for a given chain.
+         */
+        async countNullifiers(chainId) {
+            ensureChainId(chainId);
+            const prefix = `nullifiers:${chainId}:`;
+            const entries = await storage.iter({ prefix });
+            return entries.length;
+        },
+    };
+}

package/dist/state/store/records.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Locally cached metadata for a deposit note we consider owned.
+ */
+export type NoteRecord = {
+    chainId: number;
+    /** Leaf index within the on-chain tree (zero-based, monotonic). */
+    index: number;
+    /** Canonical asset identifier, typically the ERC-20 address lowercased. */
+    token: string;
+    /** Amount expressed as an unsigned BigInt serialized to a base-10 string. */
+    value: string;
+    /** Commitment stored on-chain (Poseidon(note)). */
+    commitment: string;
+    /** Note public key derived from the master public key. */
+    npk: string;
+    /**
+     * Master public key for the account (Poseidon(spendingPk.public, nullifyingKey)).
+     * Acts as the stable account identifier when grouping notes locally.
+     */
+    mpk: string;
+    /** Randomizer used when committing the note. */
+    random: string;
+    /** Nullifier that will be revealed when the note is spent. */
+    nullifier: string;
+    /** Optional timestamp when the note was marked as spent. */
+    spentAt?: number;
+};
+export type NoteInsert = Omit<NoteRecord, 'spentAt'>;
+/**
+ * Details about a nullifier observed on-chain, whether or not we own the note.
+ */
+export type NullifierRecord = {
+    chainId: number;
+    /** Nullifier value (expected to match NoteRecord.nullifier). */
+    nullifier: string;
+    /** Leaf index of the corresponding note when known. */
+    noteIndex?: number;
+};
+/**
+ * Public information about a leaf commitment inserted into the pool's tree.
+ */
+export type LeafRecord = {
+    chainId: number;
+    /** Leaf index inside the tree (zero-based). */
+    index: number;
+    /** Commitment value stored in the tree. */
+    commitment: string;
+};
+/**
+ * Historical merkle root snapshot used for proof construction.
+ */
+export type RootRecord = {
+    chainId: number;
+    /** Merkle root value committed on-chain. */
+    root: string;
+};
+//# sourceMappingURL=records.d.ts.map

package/dist/state/store/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../state/store/records.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAGF,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}

package/dist/state/store/records.js

@@ -0,0 +1 @@
+export {};

package/dist/state/store/root-store.d.ts

@@ -0,0 +1,13 @@
+import type { Storage } from "../../types.js";
+import type { RootRecord } from "../store/records.js";
+export declare function createRootStore(storage: Storage): {
+    /**
+     * Persist a historical root snapshot for proof generation.
+     */
+    putRoot(root: RootRecord): Promise<void>;
+    /**
+     * Retrieve a root snapshot by Merkle root value.
+     */
+    getRoot(chainId: number, value: string): Promise<RootRecord | null>;
+};
+//# sourceMappingURL=root-store.d.ts.map

package/dist/state/store/root-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-store.d.ts","sourceRoot":"","sources":["../../../state/store/root-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO;IAE5C;;OAEG;kBACiB,UAAU;IAU9B;;OAEG;qBACoB,MAAM,SAAS,MAAM;EAQ/C"}

package/dist/state/store/root-store.js

@@ -0,0 +1,30 @@
+import { CoreError } from "../../errors.js";
+import { keys, validateKey } from "../../keys.js";
+import { getJson, putJson } from "../../utils/json-codec.js";
+import { ensureChainId } from "../../utils/validators.js";
+export function createRootStore(storage) {
+    return {
+        /**
+         * Persist a historical root snapshot for proof generation.
+         */
+        async putRoot(root) {
+            ensureChainId(root.chainId);
+            if (typeof root.root !== "string" || root.root.length === 0) {
+                throw new CoreError("root value must be a non-empty string");
+            }
+            const key = keys.root(root.chainId, root.root);
+            validateKey(key);
+            await putJson(storage, key, root);
+        },
+        /**
+         * Retrieve a root snapshot by Merkle root value.
+         */
+        async getRoot(chainId, value) {
+            ensureChainId(chainId);
+            if (typeof value !== "string" || value.length === 0) {
+                throw new CoreError("root value must be a non-empty string");
+            }
+            return getJson(storage, keys.root(chainId, value));
+        },
+    };
+}

package/dist/state/store/store.d.ts

@@ -0,0 +1,34 @@
+import type { Storage } from "../../types.js";
+export declare function createStateStore(storage: Storage): {
+    putPendingJob(job: import("./jobs.js").PendingJobRecord): Promise<void>;
+    getPendingJob(relayId: string): Promise<import("./jobs.js").PendingJobRecord | null>;
+    listPendingJobs(filter?: {
+        kind?: import("./jobs.js").PendingJobKind;
+        statuses?: import("./jobs.js").JobStatus[];
+    }): Promise<import("./jobs.js").PendingJobRecord[]>;
+    deletePendingJob(relayId: string): Promise<void>;
+    putCiphertext(chainId: number, index: number, payload: Uint8Array): Promise<void>;
+    getCiphertext(chainId: number, index: number): Promise<Uint8Array<ArrayBuffer> | null>;
+    putRoot(root: import("./records.js").RootRecord): Promise<void>;
+    getRoot(chainId: number, value: string): Promise<import("./records.js").RootRecord | null>;
+    putLeaf(leaf: import("./records.js").LeafRecord): Promise<void>;
+    getLeaf(chainId: number, index: number): Promise<import("./records.js").LeafRecord | null>;
+    clearLeaves(chainId: number): Promise<void>;
+    putNullifier(nullifier: import("./records.js").NullifierRecord): Promise<void>;
+    getNullifier(chainId: number, value: string): Promise<import("./records.js").NullifierRecord | null>;
+    countNullifiers(chainId: number): Promise<number>;
+    putNote(note: import("./records.js").NoteInsert): Promise<void>;
+    getNote(chainId: number, index: number): Promise<import("./records.js").NoteRecord | null>;
+    listNotes(options?: {
+        chainId?: number;
+        mpk?: string;
+        token?: string;
+        includeSpent?: boolean;
+    }): Promise<import("./records.js").NoteRecord[]>;
+    markNoteSpent(chainId: number, index: number, spentAt?: number): Promise<import("./records.js").NoteRecord>;
+    markNoteUnspent(chainId: number, index: number): Promise<import("./records.js").NoteRecord>;
+    getZkBalances(mpk: string, options?: {
+        chainId?: number;
+    }): Promise<Record<string, bigint>>;
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/state/store/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../state/store/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAQ9C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO;;;;YAiBg2F,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;eAA5jC,CAAC;WAAqB,CAAC;aAAuB,CAAC;oBAA8B,CAAC;;;;;eAA+qE,CAAC;;EADtnI"}

package/dist/state/store/store.js

@@ -0,0 +1,22 @@
+import { createCiphertextStore } from "./ciphertext-store.js";
+import { createJobStore } from "./job-store.js";
+import { createLeafStore } from "./leaf-store.js";
+import { createNoteStore } from "./note-store.js";
+import { createNullifierStore } from "./nullifier-store.js";
+import { createRootStore } from "./root-store.js";
+export function createStateStore(storage) {
+    const notes = createNoteStore(storage);
+    const nullifiers = createNullifierStore(storage);
+    const leaves = createLeafStore(storage);
+    const roots = createRootStore(storage);
+    const ciphertexts = createCiphertextStore(storage);
+    const jobs = createJobStore(storage);
+    return {
+        ...notes,
+        ...nullifiers,
+        ...leaves,
+        ...roots,
+        ...ciphertexts,
+        ...jobs,
+    };
+}

package/dist/state/store.d.ts

@@ -0,0 +1,26 @@
+import type { Storage } from "../types.js";
+export declare function createStateStore(storage: Storage): {
+    putCiphertext(chainId: number, index: number, payload: Uint8Array): Promise<void>;
+    getCiphertext(chainId: number, index: number): Promise<Uint8Array<ArrayBuffer> | null>;
+    putRoot(root: import("./records.js").RootRecord): Promise<void>;
+    getRoot(chainId: number, value: string): Promise<import("./records.js").RootRecord | null>;
+    putLeaf(leaf: import("./records.js").LeafRecord): Promise<void>;
+    getLeaf(chainId: number, index: number): Promise<import("./records.js").LeafRecord | null>;
+    clearLeaves(chainId: number): Promise<void>;
+    putNullifier(nullifier: import("./records.js").NullifierRecord): Promise<void>;
+    getNullifier(chainId: number, value: string): Promise<import("./records.js").NullifierRecord | null>;
+    putNote(note: import("./records.js").NoteInsert): Promise<void>;
+    getNote(chainId: number, index: number): Promise<import("./records.js").NoteRecord | null>;
+    listNotes(options?: {
+        chainId?: number;
+        mpk?: string;
+        token?: string;
+        includeSpent?: boolean;
+    }): Promise<import("./records.js").NoteRecord[]>;
+    markNoteSpent(chainId: number, index: number, spentAt?: number): Promise<import("./records.js").NoteRecord>;
+    markNoteUnspent(chainId: number, index: number): Promise<import("./records.js").NoteRecord>;
+    getZkBalances(mpk: string, options?: {
+        chainId?: number;
+    }): Promise<Record<string, bigint>>;
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/state/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../state/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAO3C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;eAe6/C,CAAC;WAAqB,CAAC;aAAuB,CAAC;oBAA8B,CAAC;;;;;eAA+qE,CAAC;;EAD3yH"}

package/dist/state/store.js

@@ -0,0 +1,19 @@
+import { createCiphertextStore } from "./ciphertext-store.js";
+import { createLeafStore } from "./leaf-store.js";
+import { createNoteStore } from "./note-store.js";
+import { createNullifierStore } from "./nullifier-store.js";
+import { createRootStore } from "./root-store.js";
+export function createStateStore(storage) {
+    const notes = createNoteStore(storage);
+    const nullifiers = createNullifierStore(storage);
+    const leaves = createLeafStore(storage);
+    const roots = createRootStore(storage);
+    const ciphertexts = createCiphertextStore(storage);
+    return {
+        ...notes,
+        ...nullifiers,
+        ...leaves,
+        ...roots,
+        ...ciphertexts,
+    };
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,4 @@
+export { createMemoryStorage } from "./memory.js";
+export { createIndexedDbStorage, type IndexedDbOptions } from "./indexeddb.js";
+export type { Storage } from "../types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC/E,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}

package/dist/storage/index.js

@@ -0,0 +1,2 @@
+export { createMemoryStorage } from "./memory.js";
+export { createIndexedDbStorage } from "./indexeddb.js";

package/dist/storage/indexeddb.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IndexedDB-backed key/value storage for Unlink Core.
+ *
+ * What this is
+ * - A durable, transactional KV store implemented on top of the browser's IndexedDB.
+ * - Two object stores: "kv" for app data, "meta" for schema/versioning.
+ *
+ * Why we implement it
+ * - We need persistent client-side state (notes, leaves, nullifiers, cfg, etc.) that survives reloads
+ *   and works in both web apps and browser extensions without introducing a new backend.
+ *
+ * When to use
+ * - Browser UIs and extensions (MV2/MV3) where persistence is required.
+ * - Any environment with a real IndexedDB (tests use `fake-indexeddb`).
+ *
+ * Trade-offs
+ * - 👍 Durable, quota-managed, non-blocking, transactional writes (atomic batch).
+ * - 👍 Works offline; no server dependency.
+ * - ⚠️ Not natively available in Node/SSR; needs a polyfill for tests only.
+ *
+ */
+import type { Storage } from "../types.js";
+export type IndexedDbOptions = {
+    name?: string;
+};
+export declare function createIndexedDbStorage(opts?: IndexedDbOptions): Storage;
+//# sourceMappingURL=indexeddb.d.ts.map

package/dist/storage/indexeddb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexeddb.d.ts","sourceRoot":"","sources":["../../storage/indexeddb.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAuC,OAAO,EAAE,MAAM,aAAa,CAAC;AAiBhF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAsCF,wBAAgB,sBAAsB,CAAC,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAyJ3E"}

package/dist/storage/indexeddb.js

@@ -0,0 +1,205 @@
+/**
+ * IndexedDB-backed key/value storage for Unlink Core.
+ *
+ * What this is
+ * - A durable, transactional KV store implemented on top of the browser's IndexedDB.
+ * - Two object stores: "kv" for app data, "meta" for schema/versioning.
+ *
+ * Why we implement it
+ * - We need persistent client-side state (notes, leaves, nullifiers, cfg, etc.) that survives reloads
+ *   and works in both web apps and browser extensions without introducing a new backend.
+ *
+ * When to use
+ * - Browser UIs and extensions (MV2/MV3) where persistence is required.
+ * - Any environment with a real IndexedDB (tests use `fake-indexeddb`).
+ *
+ * Trade-offs
+ * - 👍 Durable, quota-managed, non-blocking, transactional writes (atomic batch).
+ * - 👍 Works offline; no server dependency.
+ * - ⚠️ Not natively available in Node/SSR; needs a polyfill for tests only.
+ *
+ */
+import { CoreError } from "../errors.js";
+import { validateKey } from "../keys.js";
+const DEFAULT_DB_NAME = "unlink-core";
+const DB_VERSION = 1;
+const KV_STORE = "kv";
+const META_STORE = "meta";
+const SCHEMA_KEY = "schema_version";
+const copy = (value) => new Uint8Array(value);
+function assertIndexedDb() {
+    if (typeof indexedDB === "undefined") {
+        throw new CoreError("indexedDB is not available in this environment");
+    }
+    return indexedDB;
+}
+// Translate IndexedDB's event-based transaction API into a promise that resolves
+// when the transaction completes or rejects on failure/abort.
+function txDone(tx) {
+    return new Promise((resolve, reject) => {
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error ?? new CoreError("indexedDB transaction failed"));
+        tx.onabort = () => reject(tx.error ?? new CoreError("indexedDB transaction aborted"));
+    });
+}
+function wrapRequest(request) {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error ?? new CoreError("indexedDB request failed"));
+    });
+}
+// Coerce whatever IndexedDB gives us back into our Bytes type.
+function asBytes(raw) {
+    if (raw instanceof Uint8Array)
+        return copy(raw);
+    if (raw instanceof ArrayBuffer)
+        return copy(new Uint8Array(raw));
+    if (ArrayBuffer.isView(raw)) {
+        const view = raw;
+        const buf = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+        return copy(new Uint8Array(buf));
+    }
+    throw new CoreError("indexedDB value is not binary data");
+}
+// IndexedDB-backed implementation implementing the storage API.
+export function createIndexedDbStorage(opts = {}) {
+    const name = opts.name ?? DEFAULT_DB_NAME;
+    let db = null;
+    // Lazy-open the database so we only touch IndexedDB when needed.
+    async function ensureOpen() {
+        if (db)
+            return db;
+        // Guard for environments without IndexedDB (unit tests or SSR).
+        const idb = assertIndexedDb();
+        const request = idb.open(name, DB_VERSION);
+        // Versioned schema: create one store for kv entries and one for metadata.
+        request.onupgradeneeded = () => {
+            const upgradeDb = request.result;
+            if (!upgradeDb.objectStoreNames.contains(KV_STORE)) {
+                upgradeDb.createObjectStore(KV_STORE);
+            }
+            if (!upgradeDb.objectStoreNames.contains(META_STORE)) {
+                upgradeDb.createObjectStore(META_STORE);
+            }
+        };
+        db = await new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error ?? new CoreError("indexedDB open failed"));
+            request.onblocked = () => reject(new CoreError("indexedDB open request was blocked"));
+        });
+        return db;
+    }
+    // Start a transaction and give callers both the store and a completion promise.
+    const getStore = async (storeName, mode) => {
+        const database = await ensureOpen();
+        const tx = database.transaction(storeName, mode);
+        const done = txDone(tx);
+        return { store: tx.objectStore(storeName), done };
+    };
+    return {
+        async open() {
+            await ensureOpen();
+        },
+        async get(key) {
+            validateKey(key);
+            const { store, done } = await getStore(KV_STORE, "readonly");
+            const result = await wrapRequest(store.get(key));
+            await done;
+            if (result === undefined)
+                return null;
+            return asBytes(result);
+        },
+        async put(key, value) {
+            validateKey(key);
+            const { store, done } = await getStore(KV_STORE, "readwrite");
+            await wrapRequest(store.put(copy(value), key)); // copy avoids shared mutation; revisit if this becomes costly
+            await done;
+        },
+        async delete(key) {
+            validateKey(key);
+            const { store, done } = await getStore(KV_STORE, "readwrite");
+            await wrapRequest(store.delete(key));
+            await done;
+        },
+        async batch(ops) {
+            // Execute the batch within a single transaction to preserve atomicity.
+            const database = await ensureOpen();
+            const tx = database.transaction(KV_STORE, "readwrite");
+            const store = tx.objectStore(KV_STORE);
+            const done = txDone(tx);
+            try {
+                // Replay the batch within a single transaction; validation failure aborts everything.
+                for (const op of ops) {
+                    if (op.put) {
+                        const [key, value] = op.put;
+                        validateKey(key);
+                        store.put(copy(value), key); // copy avoids shared mutation; revisit if this becomes costly
+                    }
+                    if (op.del) {
+                        validateKey(op.del);
+                        store.delete(op.del);
+                    }
+                }
+                await done;
+            }
+            catch (err) {
+                try {
+                    tx.abort();
+                }
+                catch (_) {
+                    /* noop */
+                }
+                await done.catch(() => { });
+                throw err;
+            }
+        },
+        async iter(options = {}) {
+            if (options.start && options.end && options.start > options.end) {
+                throw new CoreError("iter start bound must not exceed end bound");
+            }
+            // Pull everything into memory for now. TODO: stream w/ cursor when needed for perf
+            const database = await ensureOpen();
+            const tx = database.transaction(KV_STORE, "readonly");
+            const store = tx.objectStore(KV_STORE);
+            const done = txDone(tx);
+            const [keys, values] = await Promise.all([
+                wrapRequest(store.getAllKeys()),
+                wrapRequest(store.getAll()),
+            ]);
+            await done;
+            const pairs = keys.map((key, idx) => {
+                if (typeof key !== "string") {
+                    throw new CoreError("encountered non-string key in indexedDB");
+                }
+                const raw = values[idx];
+                return { key, value: asBytes(raw) };
+            });
+            let filtered = pairs.filter(({ key }) => {
+                if (options.prefix && !key.startsWith(options.prefix))
+                    return false;
+                if (options.start && key < options.start)
+                    return false;
+                if (options.end && key > options.end)
+                    return false;
+                return true;
+            });
+            filtered.sort((a, b) => a.key.localeCompare(b.key));
+            if (options.reverse)
+                filtered = filtered.reverse();
+            if (options.limit)
+                filtered = filtered.slice(0, options.limit);
+            return filtered;
+        },
+        async getSchemaVersion() {
+            const { store, done } = await getStore(META_STORE, "readonly");
+            const value = await wrapRequest(store.get(SCHEMA_KEY));
+            await done;
+            return value ?? 0;
+        },
+        async setSchemaVersion(version) {
+            const { store, done } = await getStore(META_STORE, "readwrite");
+            await wrapRequest(store.put(version, SCHEMA_KEY));
+            await done;
+        },
+    };
+}

package/dist/storage/memory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-memory key/value storage for Unlink Core.
+ *
+ * What this is
+ * - A minimal, process-local KV store backed by a `Map<string, Uint8Array>`.
+ *
+ * Why we implement it
+ * - Fast, dependency-free storage for unit tests, demos, and ephemeral runs.
+ * - Useful as a reference driver for the Storage interface.
+ *
+ * When to use
+ * - Unit tests (deterministic, zero I/O).
+ * - CLI/Node scripts that do not need persistence beyond process lifetime.
+ * - Prototyping or sandboxing Core logic.
+ *
+ * Trade-offs
+ * - 👍 Extremely fast; zero external APIs; simple to reason about.
+ * - 👍 Great for isolation in tests; easy to snapshot/clone.
+ * - ⚠️ No durability (data is lost on process exit).
+ * - ⚠️ Per-process only; no cross-tab or reload survival.
+ *
+ */
+import { Storage } from "../types.js";
+export declare function createMemoryStorage(): Storage;
+//# sourceMappingURL=memory.d.ts.map

package/dist/storage/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../storage/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAuC,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3E,wBAAgB,mBAAmB,IAAI,OAAO,CA+D7C"}

package/dist/storage/memory.js

@@ -0,0 +1,87 @@
+/**
+ * In-memory key/value storage for Unlink Core.
+ *
+ * What this is
+ * - A minimal, process-local KV store backed by a `Map<string, Uint8Array>`.
+ *
+ * Why we implement it
+ * - Fast, dependency-free storage for unit tests, demos, and ephemeral runs.
+ * - Useful as a reference driver for the Storage interface.
+ *
+ * When to use
+ * - Unit tests (deterministic, zero I/O).
+ * - CLI/Node scripts that do not need persistence beyond process lifetime.
+ * - Prototyping or sandboxing Core logic.
+ *
+ * Trade-offs
+ * - 👍 Extremely fast; zero external APIs; simple to reason about.
+ * - 👍 Great for isolation in tests; easy to snapshot/clone.
+ * - ⚠️ No durability (data is lost on process exit).
+ * - ⚠️ Per-process only; no cross-tab or reload survival.
+ *
+ */
+import { CoreError } from "../errors.js";
+import { validateKey } from "../keys.js";
+const copy = (value) => new Uint8Array(value);
+export function createMemoryStorage() {
+    const data = new Map();
+    let schema = 0;
+    return {
+        async open() { },
+        async get(k) {
+            validateKey(k);
+            return data.has(k) ? copy(data.get(k)) : null;
+        },
+        async put(k, v) {
+            validateKey(k);
+            data.set(k, copy(v));
+        },
+        async delete(k) {
+            validateKey(k);
+            data.delete(k);
+        },
+        async batch(ops) {
+            const draft = new Map(data);
+            for (const op of ops) {
+                if (op.put) {
+                    const [k, v] = op.put;
+                    validateKey(k);
+                    draft.set(k, copy(v));
+                }
+                if (op.del) {
+                    validateKey(op.del);
+                    draft.delete(op.del);
+                }
+            }
+            data.clear();
+            for (const [k, v] of draft.entries()) {
+                data.set(k, copy(v));
+            }
+        },
+        async iter(o = {}) {
+            if (o.start && o.end && o.start > o.end) {
+                throw new CoreError("iter start bound must not exceed end bound");
+            }
+            const all = [...data.entries()].map(([key, value]) => ({
+                key,
+                value: copy(value),
+            }));
+            let ks = all
+                .filter(({ key }) => (!o.prefix || key.startsWith(o.prefix)) &&
+                (!o.start || key >= o.start) &&
+                (!o.end || key <= o.end))
+                .sort((a, b) => a.key.localeCompare(b.key));
+            if (o.reverse)
+                ks.reverse();
+            if (o.limit)
+                ks = ks.slice(0, o.limit);
+            return ks;
+        },
+        async getSchemaVersion() {
+            return schema;
+        },
+        async setSchemaVersion(n) {
+            schema = n;
+        },
+    };
+}

package/dist/transactions/deposit.d.ts

@@ -0,0 +1,18 @@
+import { FetchLike } from "../clients/http.js";
+import { createIndexerClient } from "../clients/indexer.js";
+import { LocalMerkleTrees } from "../state/index.js";
+import type { DepositRelayResult, DepositRequest, DepositStateStore, DepositSyncResult } from "./types.js";
+export declare const DEPOSIT_ABI: readonly ["function deposit(address _depositor, (uint256 npk, uint256 amount, address token)[] notes, (uint256[3] data)[] ciphertexts)"];
+type DepositClientOptions = {
+    merkleTrees?: LocalMerkleTrees;
+    fetch: FetchLike;
+    pollIntervalMs?: number;
+    pollTimeoutMs?: number;
+    indexerClient?: ReturnType<typeof createIndexerClient>;
+};
+export declare function createDepositClient(stateStore: DepositStateStore, options: DepositClientOptions): {
+    request(request: DepositRequest): Promise<DepositRelayResult>;
+    syncPendingDeposit(relayId: string): Promise<DepositSyncResult>;
+};
+export {};
+//# sourceMappingURL=deposit.d.ts.map

package/dist/transactions/deposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deposit.d.ts","sourceRoot":"","sources":["../../transactions/deposit.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAoB,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG9E,OAAO,EAGL,gBAAgB,EAGjB,MAAM,mBAAmB,CAAC;AAU3B,OAAO,KAAK,EACV,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,WAAW,0IAEd,CAAC;AAGX,KAAK,oBAAoB,GAAG;IAC1B,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,KAAK,EAAE,SAAS,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;CACxD,CAAC;AAuBF,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,oBAAoB;qBAiEJ,cAAc,GAAG,OAAO,CAAC,kBAAkB,CAAC;gCA6BjC,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;EAwExE"}