@unicitylabs/sphere-sdk 0.3.8 → 0.4.0

package/dist/impl/browser/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browser_exports = {};
 __export(browser_exports, {
   BrowserTrustBaseLoader: () => BrowserTrustBaseLoader,
+  IndexedDBStorageProvider: () => IndexedDBStorageProvider,
   IndexedDBTokenStorageProvider: () => IndexedDBTokenStorageProvider,
   LocalStorageProvider: () => LocalStorageProvider,
   NostrTransportProvider: () => NostrTransportProvider,
@@ -40,6 +41,7 @@ __export(browser_exports, {
   createBrowserProviders: () => createBrowserProviders,
   createBrowserTrustBaseLoader: () => createBrowserTrustBaseLoader,
   createBrowserWebSocket: () => createBrowserWebSocket,
+  createIndexedDBStorageProvider: () => createIndexedDBStorageProvider,
   createIndexedDBTokenStorageProvider: () => createIndexedDBTokenStorageProvider,
   createLocalStorageProvider: () => createLocalStorageProvider,
   createNostrTransportProvider: () => createNostrTransportProvider,
@@ -408,9 +410,264 @@ 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";
+    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";
+      this.log("Connected to IndexedDB");
+    } catch (error) {
+      this.status = "error";
+      throw new Error(`IndexedDB not available: ${error}`);
+    }
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.status = "disconnected";
+    this.log("Disconnected from IndexedDB");
+  }
+  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) {
+      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 = () => resolve();
+          req.onerror = () => resolve();
+          req.onblocked = () => 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 {
@@ -423,7 +680,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) {
@@ -437,6 +694,7 @@ var IndexedDBTokenStorageProvider = class {
     try {
       this.db = await this.openDatabase();
       this.status = "connected";
+      this.cleanupStaleDatabases();
       return true;
     } catch (error) {
       console.error("[IndexedDBTokenStorage] Failed to initialize:", error);
@@ -594,37 +852,43 @@ var IndexedDBTokenStorageProvider = class {
     return meta !== null;
   }
   async clear() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-    this.status = "disconnected";
-    const CLEAR_TIMEOUT = 1500;
-    const withTimeout = (promise, ms, label) => Promise.race([
-      promise,
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)
-      )
-    ]);
-    const deleteDb = (name) => new Promise((resolve) => {
-      const req = indexedDB.deleteDatabase(name);
-      req.onsuccess = () => resolve();
-      req.onerror = () => resolve();
-      req.onblocked = () => resolve();
-    });
     try {
+      if (this.db) {
+        this.db.close();
+        this.db = null;
+      }
+      this.status = "disconnected";
+      const dbNames = [this.dbName];
       if (typeof indexedDB.databases === "function") {
-        const dbs = await withTimeout(
-          indexedDB.databases(),
-          CLEAR_TIMEOUT,
-          "indexedDB.databases()"
-        );
-        await Promise.all(
-          dbs.filter((db) => db.name?.startsWith(this.dbNamePrefix)).map((db) => deleteDb(db.name))
-        );
-      } else {
-        await deleteDb(this.dbName);
+        try {
+          const dbs = await Promise.race([
+            indexedDB.databases(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("timeout")), 1500)
+            )
+          ]);
+          for (const dbInfo of dbs) {
+            if (dbInfo.name && dbInfo.name.startsWith(this.dbNamePrefix) && dbInfo.name !== this.dbName) {
+              dbNames.push(dbInfo.name);
+            }
+          }
+        } catch {
+        }
       }
+      await Promise.all(dbNames.map(
+        (name) => new Promise((resolve) => {
+          try {
+            const req = indexedDB.deleteDatabase(name);
+            req.onsuccess = () => resolve();
+            req.onerror = () => resolve();
+            req.onblocked = () => {
+              resolve();
+            };
+          } catch {
+            resolve();
+          }
+        })
+      ));
       return true;
     } catch (err) {
       console.warn("[IndexedDBTokenStorage] clear() failed:", err);
@@ -634,9 +898,29 @@ var IndexedDBTokenStorageProvider = class {
   // =========================================================================
   // Private IndexedDB helpers
   // =========================================================================
+  /**
+   * Delete stale databases from other addresses (fire-and-forget, background).
+   * Called after the current database is already open, so deleteDatabase
+   * on other databases won't block anything.
+   */
+  cleanupStaleDatabases() {
+    if (typeof indexedDB.databases !== "function") return;
+    indexedDB.databases().then((dbs) => {
+      for (const dbInfo of dbs) {
+        if (dbInfo.name && dbInfo.name.startsWith(this.dbNamePrefix) && dbInfo.name !== this.dbName) {
+          const req = indexedDB.deleteDatabase(dbInfo.name);
+          req.onerror = () => {
+          };
+          req.onblocked = () => {
+          };
+        }
+      }
+    }).catch(() => {
+    });
+  }
   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);
       };
@@ -779,6 +1063,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);
@@ -1274,7 +1604,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);
@@ -1301,6 +1631,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);
@@ -1381,6 +1713,10 @@ var NostrTransportProvider = class {
   transferHandlers = /* @__PURE__ */ new Set();
   paymentRequestHandlers = /* @__PURE__ */ new Set();
   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) {
@@ -1632,6 +1968,18 @@ var NostrTransportProvider = class {
     const wrappedContent = senderNametag ? JSON.stringify({ senderNametag, text: content }) : content;
     const giftWrap = import_nostr_js_sdk.NIP17.createGiftWrap(this.keyManager, nostrRecipient, wrappedContent);
     await this.publishEvent(giftWrap);
+    const selfWrapContent = JSON.stringify({
+      selfWrap: true,
+      originalId: giftWrap.id,
+      recipientPubkey,
+      senderNametag,
+      text: content
+    });
+    const selfPubkey = this.keyManager.getPublicKeyHex();
+    const selfGiftWrap = import_nostr_js_sdk.NIP17.createGiftWrap(this.keyManager, selfPubkey, selfWrapContent);
+    this.publishEvent(selfGiftWrap).catch((err) => {
+      this.log("Self-wrap publish failed:", err);
+    });
     this.emitEvent({
       type: "message:sent",
       timestamp: Date.now(),
@@ -1641,6 +1989,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) {
@@ -1730,6 +2090,50 @@ var NostrTransportProvider = class {
     this.paymentRequestResponseHandlers.add(handler);
     return () => this.paymentRequestResponseHandlers.delete(handler);
   }
+  // ===========================================================================
+  // Read Receipts
+  // ===========================================================================
+  async sendReadReceipt(recipientTransportPubkey, messageEventId) {
+    if (!this.keyManager) throw new Error("Not initialized");
+    const nostrRecipient = recipientTransportPubkey.length === 66 ? recipientTransportPubkey.slice(2) : recipientTransportPubkey;
+    const event = import_nostr_js_sdk.NIP17.createReadReceipt(this.keyManager, nostrRecipient, messageEventId);
+    await this.publishEvent(event);
+    this.log("Sent read receipt for:", messageEventId, "to:", nostrRecipient.slice(0, 16));
+  }
+  onReadReceipt(handler) {
+    this.readReceiptHandlers.add(handler);
+    return () => this.readReceiptHandlers.delete(handler);
+  }
+  // ===========================================================================
+  // Typing Indicators
+  // ===========================================================================
+  async sendTypingIndicator(recipientTransportPubkey) {
+    if (!this.keyManager) throw new Error("Not initialized");
+    const nostrRecipient = recipientTransportPubkey.length === 66 ? recipientTransportPubkey.slice(2) : recipientTransportPubkey;
+    const content = JSON.stringify({
+      type: "typing",
+      senderNametag: this.identity?.nametag
+    });
+    const event = import_nostr_js_sdk.NIP17.createGiftWrap(this.keyManager, nostrRecipient, content);
+    await this.publishEvent(event);
+  }
+  onTypingIndicator(handler) {
+    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.
@@ -2183,11 +2587,98 @@ var NostrTransportProvider = class {
       const pm = import_nostr_js_sdk.NIP17.unwrap(event, this.keyManager);
       this.log("Gift wrap unwrapped, sender:", pm.senderPubkey?.slice(0, 16), "kind:", pm.kind);
       if (pm.senderPubkey === this.keyManager.getPublicKeyHex()) {
-        this.log("Skipping own message");
+        try {
+          const parsed = JSON.parse(pm.content);
+          if (parsed?.selfWrap && parsed.recipientPubkey) {
+            this.log("Self-wrap replay for recipient:", parsed.recipientPubkey?.slice(0, 16));
+            const message2 = {
+              id: parsed.originalId || pm.eventId,
+              senderTransportPubkey: pm.senderPubkey,
+              senderNametag: parsed.senderNametag,
+              recipientTransportPubkey: parsed.recipientPubkey,
+              content: parsed.text ?? "",
+              timestamp: pm.timestamp * 1e3,
+              encrypted: true,
+              isSelfWrap: true
+            };
+            for (const handler of this.messageHandlers) {
+              try {
+                handler(message2);
+              } catch (e) {
+                this.log("Self-wrap handler error:", e);
+              }
+            }
+            return;
+          }
+        } catch {
+        }
+        this.log("Skipping own non-self-wrap message");
         return;
       }
-      if (pm.kind !== import_nostr_js_sdk.EventKinds.CHAT_MESSAGE) {
-        this.log("Skipping non-chat message, kind:", pm.kind);
+      if ((0, import_nostr_js_sdk.isReadReceipt)(pm)) {
+        this.log("Read receipt from:", pm.senderPubkey?.slice(0, 16), "for:", pm.replyToEventId);
+        if (pm.replyToEventId) {
+          const receipt = {
+            senderTransportPubkey: pm.senderPubkey,
+            messageEventId: pm.replyToEventId,
+            timestamp: pm.timestamp * 1e3
+          };
+          for (const handler of this.readReceiptHandlers) {
+            try {
+              handler(receipt);
+            } catch (e) {
+              this.log("Read receipt handler error:", e);
+            }
+          }
+        }
+        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") {
+          this.log("Typing indicator from:", pm.senderPubkey?.slice(0, 16));
+          const indicator = {
+            senderTransportPubkey: pm.senderPubkey,
+            senderNametag: parsed.senderNametag,
+            timestamp: pm.timestamp * 1e3
+          };
+          for (const handler of this.typingIndicatorHandlers) {
+            try {
+              handler(indicator);
+            } catch (e) {
+              this.log("Typing handler error:", e);
+            }
+          }
+          return;
+        }
+      } catch {
+      }
+      if (!(0, import_nostr_js_sdk.isChatMessage)(pm)) {
+        this.log("Skipping unknown message kind:", pm.kind);
         return;
       }
       let content = pm.content;
@@ -2202,7 +2693,9 @@ var NostrTransportProvider = class {
       }
       this.log("DM received from:", senderNametag || pm.senderPubkey?.slice(0, 16), "content:", content?.slice(0, 50));
       const message = {
-        id: pm.eventId,
+        // Use outer gift wrap event.id so it matches the sender's stored giftWrap.id.
+        // This ensures read receipts reference an ID the sender recognizes.
+        id: event.id,
         senderTransportPubkey: pm.senderPubkey,
         senderNametag,
         content,
@@ -2210,12 +2703,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) {
@@ -2619,6 +3117,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 = import_nostr_js_sdk.NIP44.encrypt(JSON.stringify(rumor), this.keyManager.getPrivateKey(), recipientPubkeyBytes);
+    const sealTimestamp = now + Math.floor(Math.random() * 2 * TIMESTAMP_RANDOMIZATION) - TIMESTAMP_RANDOMIZATION;
+    const seal = import_nostr_js_sdk.Event.create(this.keyManager, {
+      kind: import_nostr_js_sdk.EventKinds.SEAL,
+      tags: [],
+      content: encryptedRumor,
+      created_at: sealTimestamp
+    });
+    const ephemeralKeys = import_nostr_js_sdk.NostrKeyManager.generate();
+    const encryptedSeal = import_nostr_js_sdk.NIP44.encrypt(JSON.stringify(seal.toJSON()), ephemeralKeys.getPrivateKey(), recipientPubkeyBytes);
+    const wrapTimestamp = now + Math.floor(Math.random() * 2 * TIMESTAMP_RANDOMIZATION) - TIMESTAMP_RANDOMIZATION;
+    const giftWrap = import_nostr_js_sdk.Event.create(ephemeralKeys, {
+      kind: import_nostr_js_sdk.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);
@@ -3248,7 +3779,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);
 }
@@ -5746,6 +6277,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") {
@@ -5803,7 +6339,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({
@@ -5812,11 +6348,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,