@decentnetwork/peer 0.1.136 → 0.1.138

package/dist/peer.js

@@ -1712,7 +1712,24 @@ export class Peer {
         this.#events.on("friendInfo", cb);
     }
     friends() {
-        return [...this.#friends.values()];
+        // Fill in `address` when the record lacks one (friends who requested US,
+        // or were adopted from a session, never carried it). The address is
+        // pubkey ‖ nospam(4B LE) ‖ checksum(2B) — locally derivable, no lookup.
+        // It is the ONLY string another person can send a friend request to, so
+        // a client that can't show it can't let its user recommend a contact
+        // (INBOX 2026-08-05). Use the friend's recorded nospam when we have it
+        // (their request told us); otherwise 0, which is what every current
+        // deployment uses.
+        return [...this.#friends.values()].map((f) => {
+            if (f.address)
+                return f;
+            try {
+                return { ...f, address: carrierAddressFromPublicKey(base58ToBytes(f.pubkey), f.nospam ?? 0) };
+            }
+            catch {
+                return f; // malformed pubkey — better an absent address than a wrong one
+            }
+        });
     }
     /**
      * Read-only snapshot of the live net_crypto session state for a

package/dist/turn.js

@@ -92,12 +92,9 @@ export class TurnClient {
         this.#nonce = nonceAttr;
         this.#integrityKey = longTermIntegrityKey(this.creds.username, this.#realm, this.creds.password);
         // Step 2: re-send ALLOCATE authenticated
-        const authed = await this.#request(TURN_ALLOCATE_REQUEST, [
+        const authed = await this.#authedRequest(TURN_ALLOCATE_REQUEST, TURN_ALLOCATE_SUCCESS, [
             { type: STUN_ATTR_REQUESTED_TRANSPORT, value: Uint8Array.of(17, 0, 0, 0) },
-            { type: STUN_ATTR_SOFTWARE, value: Buffer.from(SOFTWARE_NAME, "utf8") },
-            { type: STUN_ATTR_USERNAME, value: Buffer.from(this.creds.username, "utf8") },
-            { type: STUN_ATTR_REALM, value: Buffer.from(this.#realm, "utf8") },
-            { type: STUN_ATTR_NONCE, value: this.#nonce }
+            { type: STUN_ATTR_SOFTWARE, value: Buffer.from(SOFTWARE_NAME, "utf8") }
         ]);
         if (authed.type !== TURN_ALLOCATE_SUCCESS) {
             const err = findAttr(authed, STUN_ATTR_ERROR_CODE);
@@ -117,11 +114,8 @@ export class TurnClient {
         if (!this.#integrityKey || !this.#nonce) {
             throw new Error("createPermission called before allocate()");
         }
-        const resp = await this.#request(TURN_CREATE_PERMISSION_REQUEST, [
-            { type: STUN_ATTR_XOR_PEER_ADDRESS, value: encodeXorMappedAddress(peer, newTransactionId()) },
-            { type: STUN_ATTR_USERNAME, value: Buffer.from(this.creds.username, "utf8") },
-            { type: STUN_ATTR_REALM, value: Buffer.from(this.#realm, "utf8") },
-            { type: STUN_ATTR_NONCE, value: this.#nonce }
+        const resp = await this.#authedRequest(TURN_CREATE_PERMISSION_REQUEST, TURN_CREATE_PERMISSION_SUCCESS, [
+            { type: STUN_ATTR_XOR_PEER_ADDRESS, value: encodeXorMappedAddress(peer, newTransactionId()) }
         ]);
         if (resp.type !== TURN_CREATE_PERMISSION_SUCCESS) {
             const err = findAttr(resp, STUN_ATTR_ERROR_CODE);
@@ -152,14 +146,12 @@ export class TurnClient {
         if (!this.#integrityKey || !this.#nonce) {
             throw new Error("refresh called before allocate()");
         }
-        const resp = await this.#request(TURN_REFRESH_REQUEST, [
-            { type: STUN_ATTR_LIFETIME, value: u32Bytes(600) },
-            { type: STUN_ATTR_USERNAME, value: Buffer.from(this.creds.username, "utf8") },
-            { type: STUN_ATTR_REALM, value: Buffer.from(this.#realm, "utf8") },
-            { type: STUN_ATTR_NONCE, value: this.#nonce }
+        const resp = await this.#authedRequest(TURN_REFRESH_REQUEST, TURN_REFRESH_SUCCESS, [
+            { type: STUN_ATTR_LIFETIME, value: u32Bytes(600) }
         ]);
         if (resp.type !== TURN_REFRESH_SUCCESS) {
-            // Stale nonce — server may have rotated. Re-allocate on next call.
+            // A genuine failure (438 was already retried with the fresh nonce by
+            // #authedRequest). Drop the allocation so the next caller re-allocates.
             this.#allocation = undefined;
             const err = findAttr(resp, STUN_ATTR_ERROR_CODE);
             const decoded = err ? decodeErrorCode(err) : undefined;
@@ -206,6 +198,48 @@ export class TurnClient {
             resolve(msg);
         }
     };
+    /**
+     * Send an authenticated request, honoring nonce rotation.
+     *
+     * 438 (Stale Nonce) is NOT a failure — it is the protocol's way of rotating
+     * the nonce (RFC 5766 §4.3 / RFC 8489 §9.2): the error response carries the
+     * NEW nonce (and possibly a new realm), and the client is expected to adopt
+     * it and re-send the same request. coturn rotates every few hours; treating
+     * the 438 as fatal tore down a healthy relay on every rotation and left the
+     * refresh loop dead until the next #ensureTurnRelay (INBOX 2026-08-05).
+     *
+     * One retry only: a server that answers the fresh nonce with another 438 is
+     * genuinely refusing us, and looping would spin.
+     */
+    async #authedRequest(type, successType, attrs) {
+        const build = () => [
+            ...attrs,
+            { type: STUN_ATTR_USERNAME, value: Buffer.from(this.creds.username, "utf8") },
+            { type: STUN_ATTR_REALM, value: Buffer.from(this.#realm, "utf8") },
+            { type: STUN_ATTR_NONCE, value: this.#nonce }
+        ];
+        const resp = await this.#request(type, build());
+        if (resp.type === successType)
+            return resp;
+        const err = findAttr(resp, STUN_ATTR_ERROR_CODE);
+        const decoded = err ? decodeErrorCode(err) : undefined;
+        if (decoded?.code !== 438)
+            return resp;
+        const newNonce = findAttr(resp, STUN_ATTR_NONCE);
+        if (!newNonce)
+            return resp; // malformed 438 — nothing to retry with
+        this.#nonce = newNonce;
+        const newRealm = findAttr(resp, STUN_ATTR_REALM);
+        if (newRealm) {
+            const realm = Buffer.from(newRealm).toString("utf8");
+            if (realm !== this.#realm) {
+                // Realm change means the integrity key derives differently too.
+                this.#realm = realm;
+                this.#integrityKey = longTermIntegrityKey(this.creds.username, this.#realm, this.creds.password);
+            }
+        }
+        return this.#request(type, build());
+    }
     async #request(type, attrs) {
         const txn = newTransactionId();
         const key = Buffer.from(txn).toString("hex");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.136",
+  "version": "0.1.138",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",