@unicitylabs/sphere-sdk 0.3.8 → 0.4.0

package/dist/impl/nodejs/index.js

@@ -548,6 +548,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);
@@ -937,11 +983,14 @@ import {
   NostrKeyManager,
   NIP04,
   NIP17,
+  NIP44,
   Event as NostrEventClass,
   EventKinds,
   hashNametag,
   NostrClient,
-  Filter
+  Filter,
+  isChatMessage,
+  isReadReceipt
 } from "@unicitylabs/nostr-js-sdk";
 
 // core/crypto.ts
@@ -1052,7 +1101,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);
@@ -1079,6 +1128,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);
@@ -1159,6 +1210,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) {
@@ -1410,6 +1465,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(),
@@ -1419,6 +1486,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) {
@@ -1508,6 +1587,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 = 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);
+  }
+  // ===========================================================================
+  // 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.
@@ -1961,11 +2084,98 @@ 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 (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;
       }
-      if (pm.kind !== EventKinds.CHAT_MESSAGE) {
-        this.log("Skipping non-chat message, kind:", pm.kind);
+      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;
@@ -1980,7 +2190,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,
@@ -1988,12 +2200,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) {
@@ -2397,6 +2614,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);
@@ -2973,7 +3223,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);
 }
@@ -5458,6 +5708,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/nodejs/index.ts
 function createNodeProviders(config) {
@@ -5473,11 +5728,13 @@ function createNodeProviders(config) {
   const ipfsSync = config?.tokenSync?.ipfs;
   const ipfsTokenStorage = ipfsSync?.enabled ? createNodeIpfsStorageProvider(ipfsSync.config, storage) : 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,
     tokenStorage: createFileTokenStorageProvider({
       tokensDir: config?.tokensDir ?? "./sphere-tokens"
     }),