@unicitylabs/sphere-sdk 0.3.9 → 0.4.2

package/dist/impl/browser/index.js

@@ -350,9 +350,275 @@ function createLocalStorageProvider(config) {
   return new LocalStorageProvider(config);
 }
 
-// impl/browser/storage/IndexedDBTokenStorageProvider.ts
-var DB_NAME = "sphere-token-storage";
+// impl/browser/storage/IndexedDBStorageProvider.ts
+var DB_NAME = "sphere-storage";
 var DB_VERSION = 1;
+var STORE_NAME = "kv";
+var IndexedDBStorageProvider = class {
+  id = "indexeddb-storage";
+  name = "IndexedDB Storage";
+  type = "local";
+  description = "Browser IndexedDB for large-capacity persistence";
+  prefix;
+  dbName;
+  debug;
+  identity = null;
+  status = "disconnected";
+  db = null;
+  constructor(config) {
+    this.prefix = config?.prefix ?? "sphere_";
+    this.dbName = config?.dbName ?? DB_NAME;
+    this.debug = config?.debug ?? false;
+  }
+  // ===========================================================================
+  // BaseProvider Implementation
+  // ===========================================================================
+  async connect() {
+    if (this.status === "connected" && this.db) return;
+    this.status = "connecting";
+    console.log(`[IndexedDBStorage] connect: opening db=${this.dbName}`);
+    try {
+      this.db = await Promise.race([
+        this.openDatabase(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("IndexedDB open timed out after 5s")), 5e3)
+        )
+      ]);
+      this.status = "connected";
+      console.log(`[IndexedDBStorage] connect: connected to db=${this.dbName}`);
+    } catch (error) {
+      this.status = "error";
+      throw new Error(`IndexedDB not available: ${error}`);
+    }
+  }
+  async disconnect() {
+    console.log(`[IndexedDBStorage] disconnect: closing db=${this.dbName}, wasConnected=${!!this.db}`);
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.status = "disconnected";
+  }
+  isConnected() {
+    return this.status === "connected" && this.db !== null;
+  }
+  getStatus() {
+    return this.status;
+  }
+  // ===========================================================================
+  // StorageProvider Implementation
+  // ===========================================================================
+  setIdentity(identity) {
+    this.identity = identity;
+    this.log("Identity set:", identity.l1Address);
+  }
+  async get(key) {
+    this.ensureConnected();
+    const fullKey = this.getFullKey(key);
+    const result = await this.idbGet(fullKey);
+    return result?.v ?? null;
+  }
+  async set(key, value) {
+    this.ensureConnected();
+    const fullKey = this.getFullKey(key);
+    await this.idbPut({ k: fullKey, v: value });
+  }
+  async remove(key) {
+    this.ensureConnected();
+    const fullKey = this.getFullKey(key);
+    await this.idbDelete(fullKey);
+  }
+  async has(key) {
+    this.ensureConnected();
+    const fullKey = this.getFullKey(key);
+    const count = await this.idbCount(fullKey);
+    return count > 0;
+  }
+  async keys(prefix) {
+    this.ensureConnected();
+    const basePrefix = this.getFullKey("");
+    const searchPrefix = prefix ? this.getFullKey(prefix) : basePrefix;
+    const allEntries = await this.idbGetAll();
+    const result = [];
+    for (const entry of allEntries) {
+      if (entry.k.startsWith(searchPrefix)) {
+        result.push(entry.k.slice(basePrefix.length));
+      }
+    }
+    return result;
+  }
+  async clear(prefix) {
+    if (!prefix) {
+      console.log(`[IndexedDBStorage] clear: starting, db=${this.dbName}, wasConnected=${!!this.db}`);
+      if (this.db) {
+        this.db.close();
+        this.db = null;
+      }
+      this.status = "disconnected";
+      await new Promise((resolve) => {
+        try {
+          const req = indexedDB.deleteDatabase(this.dbName);
+          req.onsuccess = () => {
+            console.log(`[IndexedDBStorage] clear: deleted db=${this.dbName}`);
+            resolve();
+          };
+          req.onerror = () => {
+            console.warn(`[IndexedDBStorage] clear: error deleting db=${this.dbName}`, req.error);
+            resolve();
+          };
+          req.onblocked = () => {
+            console.warn(`[IndexedDBStorage] clear: deleteDatabase blocked for db=${this.dbName}`);
+            resolve();
+          };
+        } catch {
+          resolve();
+        }
+      });
+      this.log("Database deleted:", this.dbName);
+      return;
+    }
+    this.ensureConnected();
+    const keysToRemove = await this.keys(prefix);
+    for (const key of keysToRemove) {
+      await this.remove(key);
+    }
+  }
+  async saveTrackedAddresses(entries) {
+    await this.set(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES, JSON.stringify({ version: 1, addresses: entries }));
+  }
+  async loadTrackedAddresses() {
+    const data = await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES);
+    if (!data) return [];
+    try {
+      const parsed = JSON.parse(data);
+      return parsed.addresses ?? [];
+    } catch {
+      return [];
+    }
+  }
+  // ===========================================================================
+  // Helpers
+  // ===========================================================================
+  /**
+   * Get JSON data
+   */
+  async getJSON(key) {
+    const value = await this.get(key);
+    if (!value) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set JSON data
+   */
+  async setJSON(key, value) {
+    await this.set(key, JSON.stringify(value));
+  }
+  // ===========================================================================
+  // Private: Key Scoping
+  // ===========================================================================
+  getFullKey(key) {
+    const isPerAddressKey = Object.values(STORAGE_KEYS_ADDRESS).includes(key);
+    if (isPerAddressKey && this.identity?.directAddress) {
+      const addressId = getAddressId(this.identity.directAddress);
+      return `${this.prefix}${addressId}_${key}`;
+    }
+    return `${this.prefix}${key}`;
+  }
+  ensureConnected() {
+    if (this.status !== "connected" || !this.db) {
+      throw new Error("IndexedDBStorageProvider not connected");
+    }
+  }
+  // ===========================================================================
+  // Private: IndexedDB Operations
+  // ===========================================================================
+  openDatabase() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, DB_VERSION);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onblocked = () => {
+        console.warn("[IndexedDBStorageProvider] open blocked by another connection");
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "k" });
+        }
+      };
+    });
+  }
+  idbGet(key) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readonly");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.get(key);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result ?? void 0);
+    });
+  }
+  idbPut(entry) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.put(entry);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  idbDelete(key) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.delete(key);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  idbCount(key) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readonly");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.count(key);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  idbGetAll() {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readonly");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.getAll();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result ?? []);
+    });
+  }
+  idbClear() {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.clear();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[IndexedDBStorageProvider]", ...args);
+    }
+  }
+};
+function createIndexedDBStorageProvider(config) {
+  return new IndexedDBStorageProvider(config);
+}
+
+// impl/browser/storage/IndexedDBTokenStorageProvider.ts
+var DB_NAME2 = "sphere-token-storage";
+var DB_VERSION2 = 1;
 var STORE_TOKENS = "tokens";
 var STORE_META = "meta";
 var IndexedDBTokenStorageProvider = class {
@@ -365,7 +631,7 @@ var IndexedDBTokenStorageProvider = class {
   status = "disconnected";
   identity = null;
   constructor(config) {
-    this.dbNamePrefix = config?.dbNamePrefix ?? DB_NAME;
+    this.dbNamePrefix = config?.dbNamePrefix ?? DB_NAME2;
     this.dbName = this.dbNamePrefix;
   }
   setIdentity(identity) {
@@ -374,11 +640,19 @@ var IndexedDBTokenStorageProvider = class {
       const addressId = getAddressId(identity.directAddress);
       this.dbName = `${this.dbNamePrefix}-${addressId}`;
     }
+    console.log(`[IndexedDBTokenStorage] setIdentity \u2192 db=${this.dbName}`);
   }
   async initialize() {
     try {
+      if (this.db) {
+        console.log(`[IndexedDBTokenStorage] initialize: closing existing connection before re-open (db=${this.dbName})`);
+        this.db.close();
+        this.db = null;
+      }
+      console.log(`[IndexedDBTokenStorage] initialize: opening db=${this.dbName}`);
       this.db = await this.openDatabase();
       this.status = "connected";
+      console.log(`[IndexedDBTokenStorage] initialize: connected to db=${this.dbName}`);
       return true;
     } catch (error) {
       console.error("[IndexedDBTokenStorage] Failed to initialize:", error);
@@ -387,6 +661,7 @@ var IndexedDBTokenStorageProvider = class {
     }
   }
   async shutdown() {
+    console.log(`[IndexedDBTokenStorage] shutdown: closing db=${this.dbName}, wasConnected=${!!this.db}`);
     if (this.db) {
       this.db.close();
       this.db = null;
@@ -407,6 +682,7 @@ var IndexedDBTokenStorageProvider = class {
   }
   async load() {
     if (!this.db) {
+      console.warn(`[IndexedDBTokenStorage] load: db not initialized (db=${this.dbName})`);
       return {
         success: false,
         error: "Database not initialized",
@@ -455,6 +731,8 @@ var IndexedDBTokenStorageProvider = class {
       if (invalid) {
         data._invalid = invalid;
       }
+      const tokenKeys = Object.keys(data).filter((k) => k.startsWith("_") && !["_meta", "_tombstones", "_outbox", "_sent", "_invalid"].includes(k));
+      console.log(`[IndexedDBTokenStorage] load: db=${this.dbName}, tokens=${tokenKeys.length}`);
       return {
         success: true,
         data,
@@ -462,6 +740,7 @@ var IndexedDBTokenStorageProvider = class {
         timestamp: Date.now()
       };
     } catch (error) {
+      console.error(`[IndexedDBTokenStorage] load failed: db=${this.dbName}`, error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Unknown error",
@@ -472,6 +751,7 @@ var IndexedDBTokenStorageProvider = class {
   }
   async save(data) {
     if (!this.db) {
+      console.warn(`[IndexedDBTokenStorage] save: db not initialized (db=${this.dbName})`);
       return {
         success: false,
         error: "Database not initialized",
@@ -479,6 +759,9 @@ var IndexedDBTokenStorageProvider = class {
       };
     }
     try {
+      const tokenKeys = Object.keys(data).filter((k) => k.startsWith("_") && !["_meta", "_tombstones", "_outbox", "_sent", "_invalid"].includes(k));
+      const archivedKeys = Object.keys(data).filter((k) => k.startsWith("archived-"));
+      console.log(`[IndexedDBTokenStorage] save: db=${this.dbName}, tokens=${tokenKeys.length}, archived=${archivedKeys.length}, tombstones=${data._tombstones?.length ?? 0}`);
       await this.putToStore(STORE_META, "meta", data._meta);
       if (data._tombstones) {
         await this.putToStore(STORE_META, "tombstones", data._tombstones);
@@ -536,15 +819,14 @@ var IndexedDBTokenStorageProvider = class {
     return meta !== null;
   }
   async clear() {
-    const dbNames = [this.dbName];
     try {
+      console.log(`[IndexedDBTokenStorage] clear: starting, db=${this.dbName}, wasConnected=${!!this.db}`);
       if (this.db) {
-        await this.clearStore(STORE_TOKENS);
-        await this.clearStore(STORE_META);
         this.db.close();
         this.db = null;
       }
       this.status = "disconnected";
+      const dbNames = [this.dbName];
       if (typeof indexedDB.databases === "function") {
         try {
           const dbs = await Promise.race([
@@ -556,42 +838,34 @@ var IndexedDBTokenStorageProvider = class {
           for (const dbInfo of dbs) {
             if (dbInfo.name && dbInfo.name.startsWith(this.dbNamePrefix) && dbInfo.name !== this.dbName) {
               dbNames.push(dbInfo.name);
-              try {
-                const db = await new Promise((resolve, reject) => {
-                  const req = indexedDB.open(dbInfo.name, DB_VERSION);
-                  req.onsuccess = () => resolve(req.result);
-                  req.onerror = () => reject(req.error);
-                  req.onupgradeneeded = (e) => {
-                    const d = e.target.result;
-                    if (!d.objectStoreNames.contains(STORE_TOKENS)) d.createObjectStore(STORE_TOKENS, { keyPath: "id" });
-                    if (!d.objectStoreNames.contains(STORE_META)) d.createObjectStore(STORE_META);
-                  };
-                });
-                const clearTx = db.transaction([STORE_TOKENS, STORE_META], "readwrite");
-                clearTx.objectStore(STORE_TOKENS).clear();
-                clearTx.objectStore(STORE_META).clear();
-                await new Promise((resolve) => {
-                  clearTx.oncomplete = () => resolve();
-                  clearTx.onerror = () => resolve();
-                });
-                db.close();
-              } catch {
-              }
             }
           }
         } catch {
         }
       }
-      for (const name of dbNames) {
-        try {
-          const req = indexedDB.deleteDatabase(name);
-          req.onerror = () => {
-          };
-          req.onblocked = () => {
-          };
-        } catch {
-        }
-      }
+      console.log(`[IndexedDBTokenStorage] clear: deleting ${dbNames.length} database(s):`, dbNames);
+      await Promise.all(dbNames.map(
+        (name) => new Promise((resolve) => {
+          try {
+            const req = indexedDB.deleteDatabase(name);
+            req.onsuccess = () => {
+              console.log(`[IndexedDBTokenStorage] clear: deleted db=${name}`);
+              resolve();
+            };
+            req.onerror = () => {
+              console.warn(`[IndexedDBTokenStorage] clear: error deleting db=${name}`, req.error);
+              resolve();
+            };
+            req.onblocked = () => {
+              console.warn(`[IndexedDBTokenStorage] clear: deleteDatabase blocked for db=${name}`);
+              resolve();
+            };
+          } catch {
+            resolve();
+          }
+        })
+      ));
+      console.log(`[IndexedDBTokenStorage] clear: done`);
       return true;
     } catch (err) {
       console.warn("[IndexedDBTokenStorage] clear() failed:", err);
@@ -603,7 +877,7 @@ var IndexedDBTokenStorageProvider = class {
   // =========================================================================
   openDatabase() {
     return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, DB_VERSION);
+      const request = indexedDB.open(this.dbName, DB_VERSION2);
       request.onerror = () => {
         reject(request.error);
       };
@@ -746,6 +1020,52 @@ function createView(arr) {
 function rotr(word, shift) {
   return word << 32 - shift | word >>> shift;
 }
+var hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
 function createHasher(hashCons, info = {}) {
   const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
   const tmp = hashCons(void 0);
@@ -1135,6 +1455,7 @@ import {
   NostrKeyManager,
   NIP04,
   NIP17,
+  NIP44,
   Event as NostrEventClass,
   EventKinds,
   hashNametag,
@@ -1252,7 +1573,7 @@ function publicKeyToAddress(publicKey, prefix = "alpha", witnessVersion = 0) {
   const programBytes = hash160ToBytes(pubKeyHash);
   return encodeBech32(prefix, witnessVersion, programBytes);
 }
-function hexToBytes(hex) {
+function hexToBytes2(hex) {
   const matches = hex.match(/../g);
   if (!matches) {
     return new Uint8Array(0);
@@ -1279,6 +1600,8 @@ function defaultUUIDGenerator() {
 }
 
 // transport/NostrTransportProvider.ts
+var COMPOSING_INDICATOR_KIND = 25050;
+var TIMESTAMP_RANDOMIZATION = 2 * 24 * 60 * 60;
 var EVENT_KINDS = NOSTR_EVENT_KINDS;
 function hashAddressForTag(address) {
   const bytes = new TextEncoder().encode("unicity:address:" + address);
@@ -1361,6 +1684,8 @@ var NostrTransportProvider = class {
   paymentRequestResponseHandlers = /* @__PURE__ */ new Set();
   readReceiptHandlers = /* @__PURE__ */ new Set();
   typingIndicatorHandlers = /* @__PURE__ */ new Set();
+  composingHandlers = /* @__PURE__ */ new Set();
+  pendingMessages = [];
   broadcastHandlers = /* @__PURE__ */ new Map();
   eventCallbacks = /* @__PURE__ */ new Set();
   constructor(config) {
@@ -1633,6 +1958,18 @@ var NostrTransportProvider = class {
   }
   onMessage(handler) {
     this.messageHandlers.add(handler);
+    if (this.pendingMessages.length > 0) {
+      const pending = this.pendingMessages;
+      this.pendingMessages = [];
+      this.log("Flushing", pending.length, "buffered messages to new handler");
+      for (const message of pending) {
+        try {
+          handler(message);
+        } catch (error) {
+          this.log("Message handler error (buffered):", error);
+        }
+      }
+    }
     return () => this.messageHandlers.delete(handler);
   }
   async sendTokenTransfer(recipientPubkey, payload) {
@@ -1753,6 +2090,19 @@ var NostrTransportProvider = class {
     this.typingIndicatorHandlers.add(handler);
     return () => this.typingIndicatorHandlers.delete(handler);
   }
+  // ===========================================================================
+  // Composing Indicators (NIP-59 kind 25050)
+  // ===========================================================================
+  onComposing(handler) {
+    this.composingHandlers.add(handler);
+    return () => this.composingHandlers.delete(handler);
+  }
+  async sendComposingIndicator(recipientPubkey, content) {
+    this.ensureReady();
+    const nostrRecipient = recipientPubkey.length === 66 && (recipientPubkey.startsWith("02") || recipientPubkey.startsWith("03")) ? recipientPubkey.slice(2) : recipientPubkey;
+    const giftWrap = this.createCustomKindGiftWrap(nostrRecipient, content, COMPOSING_INDICATOR_KIND);
+    await this.publishEvent(giftWrap);
+  }
   /**
    * Resolve any identifier to full peer information.
    * Routes to the appropriate specific resolve method based on identifier format.
@@ -2252,6 +2602,30 @@ var NostrTransportProvider = class {
         }
         return;
       }
+      if (pm.kind === COMPOSING_INDICATOR_KIND) {
+        let senderNametag2;
+        let expiresIn = 3e4;
+        try {
+          const parsed = JSON.parse(pm.content);
+          senderNametag2 = parsed.senderNametag || void 0;
+          expiresIn = parsed.expiresIn ?? 3e4;
+        } catch {
+        }
+        const indicator = {
+          senderPubkey: pm.senderPubkey,
+          senderNametag: senderNametag2,
+          expiresIn
+        };
+        this.log("Composing indicator from:", indicator.senderNametag || pm.senderPubkey?.slice(0, 16));
+        for (const handler of this.composingHandlers) {
+          try {
+            handler(indicator);
+          } catch (e) {
+            this.log("Composing handler error:", e);
+          }
+        }
+        return;
+      }
       try {
         const parsed = JSON.parse(pm.content);
         if (parsed?.type === "typing") {
@@ -2298,12 +2672,17 @@ var NostrTransportProvider = class {
         encrypted: true
       };
       this.emitEvent({ type: "message:received", timestamp: Date.now() });
-      this.log("Dispatching to", this.messageHandlers.size, "handlers");
-      for (const handler of this.messageHandlers) {
-        try {
-          handler(message);
-        } catch (error) {
-          this.log("Message handler error:", error);
+      if (this.messageHandlers.size === 0) {
+        this.log("No message handlers registered, buffering message for later delivery");
+        this.pendingMessages.push(message);
+      } else {
+        this.log("Dispatching to", this.messageHandlers.size, "handlers");
+        for (const handler of this.messageHandlers) {
+          try {
+            handler(message);
+          } catch (error) {
+            this.log("Message handler error:", error);
+          }
         }
       }
     } catch (err) {
@@ -2707,6 +3086,39 @@ var NostrTransportProvider = class {
       }
     }
   }
+  /**
+   * Create a NIP-17 gift wrap with a custom inner rumor kind.
+   * Replicates the three-layer NIP-59 envelope (rumor → seal → gift wrap)
+   * because NIP17.createGiftWrap hardcodes kind 14 for the inner rumor.
+   */
+  createCustomKindGiftWrap(recipientPubkeyHex, content, rumorKind) {
+    const senderPubkey = this.keyManager.getPublicKeyHex();
+    const now = Math.floor(Date.now() / 1e3);
+    const rumorTags = [["p", recipientPubkeyHex]];
+    const rumorSerialized = JSON.stringify([0, senderPubkey, now, rumorKind, rumorTags, content]);
+    const rumorId = bytesToHex(sha256(new TextEncoder().encode(rumorSerialized)));
+    const rumor = { id: rumorId, pubkey: senderPubkey, created_at: now, kind: rumorKind, tags: rumorTags, content };
+    const recipientPubkeyBytes = hexToBytes(recipientPubkeyHex);
+    const encryptedRumor = NIP44.encrypt(JSON.stringify(rumor), this.keyManager.getPrivateKey(), recipientPubkeyBytes);
+    const sealTimestamp = now + Math.floor(Math.random() * 2 * TIMESTAMP_RANDOMIZATION) - TIMESTAMP_RANDOMIZATION;
+    const seal = NostrEventClass.create(this.keyManager, {
+      kind: EventKinds.SEAL,
+      tags: [],
+      content: encryptedRumor,
+      created_at: sealTimestamp
+    });
+    const ephemeralKeys = NostrKeyManager.generate();
+    const encryptedSeal = NIP44.encrypt(JSON.stringify(seal.toJSON()), ephemeralKeys.getPrivateKey(), recipientPubkeyBytes);
+    const wrapTimestamp = now + Math.floor(Math.random() * 2 * TIMESTAMP_RANDOMIZATION) - TIMESTAMP_RANDOMIZATION;
+    const giftWrap = NostrEventClass.create(ephemeralKeys, {
+      kind: EventKinds.GIFT_WRAP,
+      tags: [["p", recipientPubkeyHex]],
+      content: encryptedSeal,
+      created_at: wrapTimestamp
+    });
+    ephemeralKeys.clear();
+    return giftWrap;
+  }
   log(...args) {
     if (this.config.debug) {
       console.log("[NostrTransportProvider]", ...args);
@@ -3336,7 +3748,7 @@ async function loadLibp2pModules() {
   };
 }
 function deriveEd25519KeyMaterial(privateKeyHex, info = IPNS_HKDF_INFO) {
-  const walletSecret = hexToBytes(privateKeyHex);
+  const walletSecret = hexToBytes2(privateKeyHex);
   const infoBytes = new TextEncoder().encode(info);
   return hkdf(sha256, walletSecret, void 0, infoBytes, 32);
 }
@@ -5834,6 +6246,11 @@ function resolveGroupChatConfig(network, config) {
     relays: config.relays ?? [...netConfig.groupRelays]
   };
 }
+function resolveMarketConfig(config) {
+  if (!config) return void 0;
+  if (config === true) return {};
+  return { apiUrl: config.apiUrl, timeout: config.timeout };
+}
 
 // impl/browser/index.ts
 if (typeof globalThis.Buffer === "undefined") {
@@ -5891,7 +6308,7 @@ function createBrowserProviders(config) {
   const oracleConfig = resolveOracleConfig(network, config?.oracle);
   const l1Config = resolveL1Config(network, config?.l1);
   const tokenSyncConfig = resolveTokenSyncConfig(network, config?.tokenSync);
-  const storage = createLocalStorageProvider(config?.storage);
+  const storage = createIndexedDBStorageProvider(config?.storage);
   const priceConfig = resolvePriceConfig(config?.price, storage);
   const ipfsConfig = tokenSyncConfig?.ipfs;
   const ipfsTokenStorage = ipfsConfig?.enabled ? createBrowserIpfsStorageProvider({
@@ -5900,11 +6317,13 @@ function createBrowserProviders(config) {
     // reuse debug-like flag
   }) : void 0;
   const groupChat = resolveGroupChatConfig(network, config?.groupChat);
+  const market = resolveMarketConfig(config?.market);
   const networkConfig = getNetworkConfig(network);
   TokenRegistry.configure({ remoteUrl: networkConfig.tokenRegistryUrl, storage });
   return {
     storage,
     groupChat,
+    market,
     transport: createNostrTransportProvider({
       relays: transportConfig.relays,
       timeout: transportConfig.timeout,
@@ -5931,6 +6350,7 @@ function createBrowserProviders(config) {
 }
 export {
   BrowserTrustBaseLoader,
+  IndexedDBStorageProvider,
   IndexedDBTokenStorageProvider,
   LocalStorageProvider,
   NostrTransportProvider,
@@ -5940,6 +6360,7 @@ export {
   createBrowserProviders,
   createBrowserTrustBaseLoader,
   createBrowserWebSocket,
+  createIndexedDBStorageProvider,
   createIndexedDBTokenStorageProvider,
   createLocalStorageProvider,
   createNostrTransportProvider,