@decentnetwork/peer 0.1.37 → 0.1.38

package/dist/compat/tcp-relay-pool.d.ts

@@ -64,7 +64,7 @@ export declare class TcpRelayPool extends EventEmitter {
      * online. Returns the count of relays that accepted the write — 0 if
      * the friend isn't online on any TCP relay.
      */
-    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array): number;
+    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array, droppable?: boolean): number;
     /** Diagnostics. */
     connectedCount(): number;
     /**

package/dist/compat/tcp-relay-pool.js

@@ -173,7 +173,7 @@ export class TcpRelayPool extends EventEmitter {
      * online. Returns the count of relays that accepted the write — 0 if
      * the friend isn't online on any TCP relay.
      */
-    sendToFriend(friendPublicKey, payload) {
+    sendToFriend(friendPublicKey, payload, droppable = false) {
         if (friendPublicKey.length !== KEY_SIZE)
             return 0;
         // Send via the FIRST connected relay where the friend is online; only
@@ -191,7 +191,7 @@ export class TcpRelayPool extends EventEmitter {
                 continue;
             if (!r.client.hasFriendOnline(friendPublicKey))
                 continue;
-            if (r.client.sendToFriend(friendPublicKey, payload)) {
+            if (r.client.sendToFriend(friendPublicKey, payload, droppable)) {
                 return 1;
             }
         }

package/dist/compat/tcp-relay.d.ts

@@ -82,11 +82,11 @@ export declare class TcpRelayClient extends EventEmitter {
      * if the relay says they're offline. Caller should treat false as
      * "try another transport".
      */
-    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array): boolean;
+    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array, droppable?: boolean): boolean;
     /** Send a PING; relay echoes it as PONG. ping_id is opaque 8 bytes. */
     sendPing(): boolean;
     /** Send DATA payload to the friend at `connectionId`. */
-    sendData(connectionId: number, payload: Uint8Array): boolean;
+    sendData(connectionId: number, payload: Uint8Array, droppable?: boolean): boolean;
     /** Send OOB_SEND (used for delivering friend requests via TCP relay). */
     sendOob(receiverPublicKey: Uint8Array, payload: Uint8Array): boolean;
     close(reason?: string): void;

package/dist/compat/tcp-relay.js

@@ -37,6 +37,15 @@ import { incrementNonce } from "./net-crypto.js";
 const KEY_SIZE = 32;
 const NONCE_SIZE = 24;
 const MAC_SIZE = 16;
+// Max bytes we let pile up in the relay socket's write buffer before we start
+// DROPPING droppable (bulk IP) frames. Node's socket.write() buffers without
+// bound when the kernel send buffer is full, so a congested relay link would
+// otherwise queue SECONDS of IP packets — the multi-second bufferbloat behind
+// the snoopy/lili 13s pings. ~64KB is well under a second of queue even on a
+// slow transpacific relay; past it we behave like a real congested network and
+// drop, letting the inner protocol (TCP/QUIC) retransmit instead of delivering
+// stale packets late. Control frames (droppable=false) always go through.
+const RELAY_SEND_BUFFER_CAP = 64 * 1024;
 /** TCP_HANDSHAKE_PLAIN_SIZE in toxcore — temp pubkey + initial nonce. */
 const TCP_HANDSHAKE_PLAIN_SIZE = KEY_SIZE + NONCE_SIZE;
 /** Outbound handshake: self_dht_pk(32) + nonce(24) + box(plain)(KEY_SIZE+NONCE_SIZE+MAC_SIZE = 72) = 128. */
@@ -276,13 +285,18 @@ export class TcpRelayClient extends EventEmitter {
         return opened;
     }
     /** Encrypt a payload and write it as one framed packet. */
-    #sendFrame(payload) {
+    #sendFrame(payload, droppable = false) {
         if (this.#state !== "connected" || !this.#sessionKey || !this.#sentNonce || !this.#socket) {
             return false;
         }
         if (payload.length === 0 || payload.length > MAX_PACKET_SIZE - MAC_SIZE) {
             return false;
         }
+        // Bound the relay queue: drop bulk IP frames once the socket buffer is
+        // backed up rather than letting Node buffer seconds of packets (bufferbloat).
+        if (droppable && this.#socket.writableLength > RELAY_SEND_BUFFER_CAP) {
+            return false;
+        }
         const cipher = nacl.secretbox(payload, this.#sentNonce, this.#sessionKey);
         incrementNonce(this.#sentNonce);
         // Wire layout: [4-byte iveg][2-byte BE length][cipher].
@@ -418,13 +432,13 @@ export class TcpRelayClient extends EventEmitter {
      * if the relay says they're offline. Caller should treat false as
      * "try another transport".
      */
-    sendToFriend(friendPublicKey, payload) {
+    sendToFriend(friendPublicKey, payload, droppable = false) {
         if (friendPublicKey.length !== KEY_SIZE)
             return false;
         const cid = this.#cidByFriend.get(Buffer.from(friendPublicKey).toString("hex"));
         if (cid === undefined)
             return false;
-        return this.sendData(cid, payload);
+        return this.sendData(cid, payload, droppable);
     }
     /** Send a PING; relay echoes it as PONG. ping_id is opaque 8 bytes. */
     sendPing() {
@@ -432,12 +446,12 @@ export class TcpRelayClient extends EventEmitter {
         return this.#sendFrame(concatBytes([Uint8Array.of(TCP_PACKET_PING), pingId]));
     }
     /** Send DATA payload to the friend at `connectionId`. */
-    sendData(connectionId, payload) {
+    sendData(connectionId, payload, droppable = false) {
         if (connectionId < 16 || connectionId > 0xff)
             return false;
         if (payload.length === 0)
             return false;
-        return this.#sendFrame(concatBytes([Uint8Array.of(connectionId), payload]));
+        return this.#sendFrame(concatBytes([Uint8Array.of(connectionId), payload]), droppable);
     }
     /** Send OOB_SEND (used for delivering friend requests via TCP relay). */
     sendOob(receiverPublicKey, payload) {

package/dist/peer.js

@@ -2775,7 +2775,10 @@ export class Peer {
                 // would silently drop on iPad's side and leave the session
                 // looking healthy on our side while iPad never sees the
                 // packets.
-                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet);
+                // Bulk IP data is droppable over the relay: under backpressure the
+                // relay client drops it (bounded queue) rather than buffering seconds
+                // of packets. Control frames pass isBulkData=false and always queue.
+                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet, isBulkData);
                 if (sent > 0) {
                     tcpOk = true;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "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",