@unicitylabs/sphere-sdk 0.3.6 → 0.3.7

package/dist/impl/browser/index.js

@@ -533,36 +533,61 @@ 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();
-    });
+    const dbNames = [this.dbName];
     try {
+      if (this.db) {
+        await this.clearStore(STORE_TOKENS);
+        await this.clearStore(STORE_META);
+        this.db.close();
+        this.db = null;
+      }
+      this.status = "disconnected";
       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);
+              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 {
+        }
       }
       return true;
     } catch (err) {
@@ -1111,7 +1136,9 @@ import {
   EventKinds,
   hashNametag,
   NostrClient,
-  Filter
+  Filter,
+  isChatMessage,
+  isReadReceipt
 } from "@unicitylabs/nostr-js-sdk";
 
 // core/crypto.ts
@@ -1329,6 +1356,8 @@ var NostrTransportProvider = class {
   transferHandlers = /* @__PURE__ */ new Set();
   paymentRequestHandlers = /* @__PURE__ */ new Set();
   paymentRequestResponseHandlers = /* @__PURE__ */ new Set();
+  readReceiptHandlers = /* @__PURE__ */ new Set();
+  typingIndicatorHandlers = /* @__PURE__ */ new Set();
   broadcastHandlers = /* @__PURE__ */ new Map();
   eventCallbacks = /* @__PURE__ */ new Set();
   constructor(config) {
@@ -1580,6 +1609,18 @@ var NostrTransportProvider = class {
     const wrappedContent = senderNametag ? JSON.stringify({ senderNametag, text: content }) : content;
     const giftWrap = 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 = 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(),
@@ -1678,6 +1719,37 @@ 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 = 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 = NIP17.createGiftWrap(this.keyManager, nostrRecipient, content);
+    await this.publishEvent(event);
+  }
+  onTypingIndicator(handler) {
+    this.typingIndicatorHandlers.add(handler);
+    return () => this.typingIndicatorHandlers.delete(handler);
+  }
   /**
    * Resolve any identifier to full peer information.
    * Routes to the appropriate specific resolve method based on identifier format.
@@ -2131,11 +2203,74 @@ var NostrTransportProvider = class {
       const pm = 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 !== EventKinds.CHAT_MESSAGE) {
-        this.log("Skipping non-chat message, kind:", pm.kind);
+      if (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;
+      }
+      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 (!isChatMessage(pm)) {
+        this.log("Skipping unknown message kind:", pm.kind);
         return;
       }
       let content = pm.content;
@@ -2150,7 +2285,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,