wireweave 0.3.43 → 0.3.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wireweave",
-  "version": "0.3.43",
+  "version": "0.3.45",
   "description": "nostr + webrtc voice + data SDK. networking layer for 247420 projects.",
   "type": "module",
   "main": "./src/index.js",

package/src/data.js

@@ -16,9 +16,37 @@ const DEFAULT_ICE_SERVERS = [
   { urls: 'turn:openrelay.metered.ca:443?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' }
 ];
 let ICE_SERVERS = DEFAULT_ICE_SERVERS;
-export const setIceServers = (list) => { if (Array.isArray(list) && list.length) ICE_SERVERS = list; };
+let iceServersOverridden = false;
+export const setIceServers = (list) => { if (Array.isArray(list) && list.length) { ICE_SERVERS = list; iceServersOverridden = true; } };
 export const getIceServers = () => ICE_SERVERS.slice();
 
+// The bundled TURN entries use the openrelayproject public demo credentials
+// (metered.ca's shared, rate-limited, no-SLA relay). Fine for local dev/testing,
+// but a real hosted deployment that never calls setIceServers() is silently
+// depending on a third party's free-tier relay for every NAT-restricted peer —
+// warn once, at first connect, so that's discoverable instead of a mystery
+// "some players can never connect" bug report. Never fires on localhost/loopback
+// dev servers, and never fires once the host has provided its own iceServers.
+let defaultTurnWarned = false;
+const isHostedDeployment = () => {
+  try {
+    const host = typeof location !== 'undefined' && location.hostname;
+    if (!host) return false;
+    if (host === 'localhost' || host === '127.0.0.1' || host === '[::1]' || host === '') return false;
+    if (host.endsWith('.local')) return false;
+    return true;
+  } catch { return false; }
+};
+const warnDefaultTurnCredentialsOnce = () => {
+  if (defaultTurnWarned || iceServersOverridden) return;
+  if (!isHostedDeployment()) return;
+  defaultTurnWarned = true;
+  console.warn('[wireweave] Using the bundled default TURN servers (openrelayproject shared public credentials) ' +
+    'on a non-localhost deployment. These are a free, rate-limited, no-SLA relay meant for local dev/testing — ' +
+    'NAT-restricted peers on this deployment may fail to connect or get throttled. Call setIceServers() with your ' +
+    'own TURN credentials before connecting.');
+};
+
 const PRESENCE_EXPIRY = 300000;
 const HEARTBEAT = 30000;
 const DISCONNECT_GRACE = 8000;
@@ -64,6 +92,7 @@ export class DataSession extends EventTarget {
   }
 
   async connect(room, { displayName = 'Guest' } = {}) {
+    warnDefaultTurnCredentialsOnce();
     if (!this.actor) this._initActor();
     if (!this.actor.getSnapshot().can({ type: 'connect' })) await this.disconnect();
     this.actor.send({ type: 'connect' });

package/src/dm.js

@@ -1,41 +1,53 @@
+const GIFT_WRAP_KIND = 1059;
+
 export class DM extends EventTarget {
     constructor({ relayPool, auth, nostrTools }) {
         super();
         if (!relayPool || !auth || !nostrTools) throw new Error('DM: deps required');
         if (!nostrTools.nip44) throw new Error('nostr-tools nip44 missing');
+        if (!nostrTools.nip59) throw new Error('nostr-tools nip59 missing');
         this.pool = relayPool;
         this.auth = auth;
         this.NT = nostrTools;
         this.subId = null;
     }
 
-    _convKey(peerPubkey) {
-        if (!this.auth.privkey) throw new Error('DM: privkey required (extension signing not supported for nip44)');
-        return this.NT.nip44.v2.utils.getConversationKey
-            ? this.NT.nip44.v2.utils.getConversationKey(this.auth.privkey, peerPubkey)
-            : this.NT.nip44.getConversationKey(this.auth.privkey, peerPubkey);
-    }
-
+    // NIP-17: send is a real kind:14 rumor, gift-wrapped (NIP-59) once per
+    // recipient and once more for ourselves (self-copy), each wrap signed by
+    // a fresh single-use random key so no relay observer can attribute the
+    // wrap's outer envelope to either the sender or the recipient — only the
+    // holder of the recipient's (or our own) private key can even see it's a
+    // DM at all, let alone read it or learn who sent it.
     async send(peerPubkey, plaintext) {
-        const key = this._convKey(peerPubkey);
-        const ciphertext = this.NT.nip44.v2.encrypt(plaintext, key);
-        const signed = await this.auth.sign({
+        if (!this.auth.privkey) throw new Error('DM: privkey required (extension signing not supported for nip17)');
+        const rumor = {
             kind: 14,
             created_at: Math.floor(Date.now() / 1000),
             tags: [['p', peerPubkey]],
-            content: ciphertext
-        });
-        this.pool.publish(signed);
-        return signed;
+            content: plaintext
+        };
+        const wrapForPeer = this.NT.nip59.wrapEvent(rumor, this.auth.privkey, peerPubkey);
+        const wrapForSelf = this.NT.nip59.wrapEvent(rumor, this.auth.privkey, this.auth.pubkey);
+        this.pool.publish(wrapForPeer);
+        this.pool.publish(wrapForSelf);
+        return wrapForPeer;
+    }
+
+    // Unwrap a gift-wrap (kind 1059) down to its rumor and return the
+    // plaintext. Requires our own privkey — only the wrap's addressed
+    // recipient (the 'p' tag on the outer event) can unwrap it.
+    decrypt(wrap) {
+        if (!this.auth.privkey) throw new Error('DM: privkey required (extension signing not supported for nip17)');
+        const rumor = this.NT.nip59.unwrapEvent(wrap, this.auth.privkey);
+        return rumor.content;
     }
 
-    decrypt(event) {
-        const peer = event.pubkey === this.auth.pubkey
-            ? (event.tags.find(t => t[0] === 'p')?.[1] || '')
-            : event.pubkey;
-        if (!peer) throw new Error('DM: cannot resolve peer');
-        const key = this._convKey(peer);
-        return this.NT.nip44.v2.decrypt(event.content, key);
+    // Same as decrypt() but returns the full unwrapped rumor (sender pubkey,
+    // created_at, tags) alongside the plaintext, for callers that need the
+    // real (rumor-level) sender identity rather than the wrap's throwaway key.
+    unwrap(wrap) {
+        if (!this.auth.privkey) throw new Error('DM: privkey required (extension signing not supported for nip17)');
+        return this.NT.nip59.unwrapEvent(wrap, this.auth.privkey);
     }
 
     subscribe(onMessage) {
@@ -43,14 +55,14 @@ export class DM extends EventTarget {
         const subId = 'dm-' + this.auth.pubkey.slice(0, 16);
         this.subId = subId;
         this.pool.subscribe(subId, [
-            { kinds: [14], '#p': [this.auth.pubkey] },
-            { kinds: [14], authors: [this.auth.pubkey] }
+            { kinds: [GIFT_WRAP_KIND], '#p': [this.auth.pubkey] }
         ], (event) => {
             try {
-                const plaintext = this.decrypt(event);
-                onMessage({ event, plaintext, peer: event.pubkey === this.auth.pubkey
-                    ? (event.tags.find(t => t[0] === 'p')?.[1] || '')
-                    : event.pubkey });
+                const rumor = this.unwrap(event);
+                const peer = rumor.pubkey === this.auth.pubkey
+                    ? (rumor.tags.find(t => t[0] === 'p')?.[1] || '')
+                    : rumor.pubkey;
+                onMessage({ event, rumor, plaintext: rumor.content, peer });
             } catch (e) {
                 this._emit('error', { event, error: e.message });
             }