@unicitylabs/sphere-sdk 0.3.9 → 0.4.0

package/dist/impl/nodejs/index.cjs

@@ -597,6 +597,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);
@@ -1092,7 +1138,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);
@@ -1119,6 +1165,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);
@@ -1201,6 +1249,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) {
@@ -1473,6 +1523,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) {
@@ -1593,6 +1655,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.
@@ -2092,6 +2167,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") {
@@ -2138,12 +2237,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) {
@@ -2547,6 +2651,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);
@@ -3123,7 +3260,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);
 }
@@ -5608,6 +5745,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) {
@@ -5623,11 +5765,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"
     }),