@orbinum/sdk 0.25.1 → 1.0.0

package/dist/adapters/indexeddb/index.mjs

@@ -0,0 +1,326 @@
+import {
+  createDeviceKeyProvider
+} from "../../chunk-JMYU5QAK.mjs";
+
+// src/adapters/indexeddb/idb.ts
+function idbRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+// src/adapters/indexeddb/VaultStorage.ts
+var DB_VERSION = 1;
+var STORE_CONFIG = "vault_config";
+var STORE_NOTES = "vault_notes";
+var STORE_TX_HISTORY = "vault_tx_history";
+var STORE_NULLIFIERS = "nullifier_set";
+var STORE_NULLIFIER_SYNC = "nullifier_sync";
+var IndexedDbVaultStorage = class {
+  name;
+  idb;
+  db = null;
+  constructor(options) {
+    this.name = options.name;
+    const factory = options.indexedDB ?? globalThis.indexedDB;
+    if (!factory) {
+      throw new Error(
+        "IndexedDB is unavailable. Pass `indexedDB`, or use a different VaultStorage."
+      );
+    }
+    this.idb = factory;
+  }
+  openDB() {
+    if (this.db) return Promise.resolve(this.db);
+    return new Promise((resolve, reject) => {
+      const req = this.idb.open(this.name, DB_VERSION);
+      req.onupgradeneeded = (e) => {
+        const db = e.target.result;
+        for (const [store, keyPath] of [
+          [STORE_CONFIG, "id"],
+          [STORE_NOTES, "commitmentTag"],
+          [STORE_TX_HISTORY, "id"],
+          [STORE_NULLIFIERS, "h"],
+          [STORE_NULLIFIER_SYNC, "id"]
+        ]) {
+          if (!db.objectStoreNames.contains(store)) {
+            db.createObjectStore(store, { keyPath });
+          }
+        }
+      };
+      req.onsuccess = (e) => {
+        const db = e.target.result;
+        db.onclose = () => {
+          if (this.db === db) this.db = null;
+        };
+        db.onversionchange = () => {
+          db.close();
+          if (this.db === db) this.db = null;
+        };
+        this.db = db;
+        resolve(db);
+      };
+      req.onerror = () => reject(new Error(`Failed to open IndexedDB: ${String(req.error?.message)}`));
+    });
+  }
+  /**
+   * Runs one transaction, reopening once if the cached connection was already
+   * dead.
+   *
+   * `onclose` does not fire in every closing path — notably a connection
+   * killed between `openDB()` and the transaction call — so this retry is what
+   * actually makes the adapter self-healing. `InvalidStateError` means "this
+   * handle is finished", and a fresh one is the only fix. Once is enough: a
+   * second failure is a real problem, not a stale handle.
+   *
+   * `run` must build its requests synchronously (no await before the last
+   * one), or the transaction auto-commits underneath it.
+   */
+  async withDB(run) {
+    try {
+      return await run(await this.openDB());
+    } catch (err) {
+      if (err?.name !== "InvalidStateError") throw err;
+      this.db = null;
+      return run(await this.openDB());
+    }
+  }
+  // ── Config ───────────────────────────────────────────────────────────────
+  async getConfig() {
+    return this.withDB(async (db) => {
+      const tx = db.transaction(STORE_CONFIG, "readonly");
+      const result = await idbRequest(
+        tx.objectStore(STORE_CONFIG).get("main")
+      );
+      return result ?? null;
+    });
+  }
+  async putConfig(config) {
+    await this.withDB(async (db) => {
+      const tx = db.transaction(STORE_CONFIG, "readwrite");
+      await idbRequest(tx.objectStore(STORE_CONFIG).put(config));
+    });
+  }
+  /**
+   * Read-modify-write in ONE transaction.
+   *
+   * Doing this as getConfig() then putConfig() spans two transactions, so two
+   * concurrent callers both read the old record and the second write wins. For
+   * `selfEphCounter` that lost increment means two notes derive the SAME
+   * ephemeral index and publish one ephPk twice, linking them as
+   * same-creator — a privacy leak, not a lost UI update. A single readwrite
+   * transaction serialises them, since IndexedDB scopes those per store.
+   */
+  async updateConfig(mutate) {
+    return this.withDB(async (db) => {
+      const tx = db.transaction(STORE_CONFIG, "readwrite");
+      const store = tx.objectStore(STORE_CONFIG);
+      const current = await idbRequest(store.get("main"));
+      if (!current) return null;
+      const updated = mutate(current);
+      await idbRequest(store.put(updated));
+      return updated;
+    });
+  }
+  async hasVault() {
+    return await this.getConfig() !== null;
+  }
+  // ── Notes ────────────────────────────────────────────────────────────────
+  async getAllNoteRecords() {
+    return this.withDB((db) => {
+      const tx = db.transaction(STORE_NOTES, "readonly");
+      return idbRequest(tx.objectStore(STORE_NOTES).getAll());
+    });
+  }
+  async putNote(record) {
+    await this.putNotes([record]);
+  }
+  async putNotes(records) {
+    if (records.length === 0) return;
+    await this.withDB(async (db) => {
+      const tx = db.transaction(STORE_NOTES, "readwrite");
+      const store = tx.objectStore(STORE_NOTES);
+      await Promise.all(records.map((r) => idbRequest(store.put(r))));
+    });
+  }
+  async deleteNote(commitmentTag) {
+    await this.deleteNotes([commitmentTag]);
+  }
+  async deleteNotes(commitmentTags) {
+    if (commitmentTags.length === 0) return;
+    await this.withDB(async (db) => {
+      const tx = db.transaction(STORE_NOTES, "readwrite");
+      const store = tx.objectStore(STORE_NOTES);
+      await Promise.all(commitmentTags.map((tag) => idbRequest(store.delete(tag))));
+    });
+  }
+  async clearNotes() {
+    await this.withDB(async (db) => {
+      const tx = db.transaction(STORE_NOTES, "readwrite");
+      await idbRequest(tx.objectStore(STORE_NOTES).clear());
+    });
+  }
+  // ── Transaction history ──────────────────────────────────────────────────
+  // Storage-dumb: rows are written and read as-is. Encryption lives in
+  // VaultStore, which is what a caller should use.
+  async addTxRecord(record) {
+    await this.withDB(async (db) => {
+      const tx = db.transaction(STORE_TX_HISTORY, "readwrite");
+      await idbRequest(tx.objectStore(STORE_TX_HISTORY).put(record));
+    });
+  }
+  async getAllTxRecords() {
+    return this.withDB((db) => {
+      const tx = db.transaction(STORE_TX_HISTORY, "readonly");
+      return idbRequest(tx.objectStore(STORE_TX_HISTORY).getAll());
+    });
+  }
+  // ── Nullifier cache ──────────────────────────────────────────────────────
+  /**
+   * Persists one sealed chunk AND the sync progress it produced in a single
+   * transaction. Both must land together: progress ahead of the data would
+   * make the next sync resume past chunks that were never stored, leaving
+   * spent notes looking unspent.
+   */
+  async putNullifierChunk(entries, meta) {
+    await this.withDB(async (db) => {
+      const tx = db.transaction([STORE_NULLIFIERS, STORE_NULLIFIER_SYNC], "readwrite");
+      const store = tx.objectStore(STORE_NULLIFIERS);
+      await Promise.all([
+        ...entries.map((e) => idbRequest(store.put(e))),
+        idbRequest(tx.objectStore(STORE_NULLIFIER_SYNC).put(meta))
+      ]);
+    });
+  }
+  async getNullifierSyncMeta() {
+    return this.withDB(async (db) => {
+      const tx = db.transaction(STORE_NULLIFIER_SYNC, "readonly");
+      const result = await idbRequest(
+        tx.objectStore(STORE_NULLIFIER_SYNC).get("main")
+      );
+      return result ?? null;
+    });
+  }
+  /**
+   * Which of `hexes` the cache holds, as batch point-gets.
+   *
+   * Local lookups are the whole point: asking a server whether one specific
+   * nullifier is spent would tell it which notes this wallet owns.
+   */
+  async getSpentNullifiers(hexes) {
+    if (hexes.length === 0) return /* @__PURE__ */ new Map();
+    return this.withDB(async (db) => {
+      const tx = db.transaction(STORE_NULLIFIERS, "readonly");
+      const store = tx.objectStore(STORE_NULLIFIERS);
+      const results = await Promise.all(
+        hexes.map((h) => idbRequest(store.get(h)))
+      );
+      return new Map(
+        results.filter((r) => r !== void 0).map((r) => [r.h, { spentAt: r.ts ?? null, txHash: r.tx ?? null }])
+      );
+    });
+  }
+  async countNullifiers() {
+    return this.withDB((db) => {
+      const tx = db.transaction(STORE_NULLIFIERS, "readonly");
+      return idbRequest(tx.objectStore(STORE_NULLIFIERS).count());
+    });
+  }
+  async clearNullifierCache() {
+    await this.withDB(async (db) => {
+      const tx = db.transaction([STORE_NULLIFIERS, STORE_NULLIFIER_SYNC], "readwrite");
+      await Promise.all([
+        idbRequest(tx.objectStore(STORE_NULLIFIERS).clear()),
+        idbRequest(tx.objectStore(STORE_NULLIFIER_SYNC).clear())
+      ]);
+    });
+  }
+  /** Closes the cached connection. The next call reopens it. */
+  close() {
+    this.db?.close();
+    this.db = null;
+  }
+};
+
+// src/adapters/indexeddb/deviceKeyStore.ts
+var KEYSTORE_DB = "orbinum-keystore";
+var KEYSTORE_STORE = "keys";
+var DEVICE_KEY_ID = "device";
+function createIndexedDbDeviceKeyStore(indexedDBFactory) {
+  const idb = indexedDBFactory ?? globalThis.indexedDB;
+  if (!idb) throw new Error("IndexedDB is unavailable; supply a different DeviceKeyStore.");
+  const open = () => new Promise((resolve, reject) => {
+    const req = idb.open(KEYSTORE_DB, 1);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(KEYSTORE_STORE)) {
+        db.createObjectStore(KEYSTORE_STORE, { keyPath: "id" });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(new Error(`Failed to open keystore: ${String(req.error?.message)}`));
+  });
+  return {
+    async load() {
+      const db = await open();
+      try {
+        const row = await idbRequest(
+          db.transaction(KEYSTORE_STORE, "readonly").objectStore(KEYSTORE_STORE).get(DEVICE_KEY_ID)
+        );
+        return row?.key ?? null;
+      } finally {
+        db.close();
+      }
+    },
+    async save(key) {
+      const db = await open();
+      try {
+        await idbRequest(
+          db.transaction(KEYSTORE_STORE, "readwrite").objectStore(KEYSTORE_STORE).put({ id: DEVICE_KEY_ID, key })
+        );
+      } finally {
+        db.close();
+      }
+    }
+  };
+}
+var getOrCreateIndexedDbDeviceKey = createDeviceKeyProvider({
+  load: () => createIndexedDbDeviceKeyStore().load(),
+  save: (key) => createIndexedDbDeviceKeyStore().save(key)
+});
+
+// src/adapters/indexeddb/secretStore.ts
+function createWebStorageSecretStore(storage, sessionStorageArea) {
+  const durable = () => {
+    const area = storage ?? globalThis.localStorage;
+    if (!area) throw new Error("Web Storage is unavailable; supply a different SecretStore.");
+    return area;
+  };
+  const session = () => sessionStorageArea === void 0 ? globalThis.sessionStorage ?? null : sessionStorageArea;
+  return {
+    async get(key) {
+      return durable().getItem(key) ?? session()?.getItem(key) ?? null;
+    },
+    async set(key, value) {
+      durable().setItem(key, value);
+      session()?.removeItem(key);
+    },
+    async remove(key) {
+      durable().removeItem(key);
+      session()?.removeItem(key);
+    },
+    async keys() {
+      const all = new Set(Object.keys(durable()));
+      const area = session();
+      if (area) for (const k of Object.keys(area)) all.add(k);
+      return [...all];
+    }
+  };
+}
+export {
+  IndexedDbVaultStorage,
+  createIndexedDbDeviceKeyStore,
+  createWebStorageSecretStore,
+  getOrCreateIndexedDbDeviceKey
+};

package/dist/chunk-JMYU5QAK.mjs

@@ -0,0 +1,40 @@
+// src/wallet/identity/deviceKey.ts
+async function generateDeviceKey(extractable = false) {
+  return crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, extractable, [
+    "encrypt",
+    "decrypt"
+  ]);
+}
+async function importDeviceKey(raw) {
+  if (raw.length !== 32) {
+    throw new Error(`Device key must be 32 bytes, got ${raw.length}.`);
+  }
+  return crypto.subtle.importKey("raw", raw.slice(0), "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+function createDeviceKeyProvider(store) {
+  let cached = null;
+  let inFlight = null;
+  return async function getOrCreateDeviceKey() {
+    if (cached) return cached;
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      const existing = await store.load();
+      if (existing) return existing;
+      const key = await generateDeviceKey();
+      await store.save(key);
+      return key;
+    })();
+    try {
+      cached = await inFlight;
+      return cached;
+    } finally {
+      inFlight = null;
+    }
+  };
+}
+
+export {
+  generateDeviceKey,
+  importDeviceKey,
+  createDeviceKeyProvider
+};