@decentnetwork/peer 0.1.120 → 0.1.122

package/dist/peer.js

@@ -60,7 +60,10 @@ const DHT_MAINTENANCE_INTERVAL_MS = readEnvInt("DECENT_DHT_MAINTENANCE_INTERVAL_
 // distance-sort it feeds) without limit — which starved CCTV forwarding over time.
 const MAX_KNOWN_NODES = readEnvInt("DECENT_MAX_KNOWN_NODES", 400);
 const MAX_SELF_ANNOUNCE_TARGETS = readEnvInt("DECENT_SELF_ANNOUNCE_TARGETS", 16);
-const SELF_ANNOUNCE_ATTEMPTS = readEnvInt("DECENT_SELF_ANNOUNCE_ATTEMPTS", 3);
+// 1 (was 3): a dead node cost attempts×ANNOUNCE_WAIT = 12s — one wave of
+// dead nodes ate the entire per-cycle deadline, so the walk never got past
+// wave 1 and stored on ~1 node per DAY. The 12s cycle itself is the retry.
+const SELF_ANNOUNCE_ATTEMPTS = readEnvInt("DECENT_SELF_ANNOUNCE_ATTEMPTS", 1);
 // Self-announce batch size — number of step1 / step2 requests to fan out
 // at once. Toxcore's onion_client.c::do_announce keeps up to
 // MAX_ONION_CLIENTS_ANNOUNCE (12) in flight. Configurable via env.
@@ -5213,7 +5216,11 @@ export class Peer {
         // Prefer DHT key learned from DHTPK updates; fallback to real key.
         const friendDhtPk = session?.friendDhtPublicKey ?? friendRealPk;
         const connectCandidates = this.#collectSessionEndpointCandidates(friendId, friend, session);
-        const tcpAvailable = !!this.#tcpRelays?.isFriendOnline(friendRealPk);
+        // Natives are known to the relay by their DHT key, not their identity
+        // key — check both, else tcpAvailable stays false for every native.
+        const dhtKeyForTcp = session?.friendDhtPublicKey ?? this.#friendDhtKeys.get(friendId);
+        const tcpAvailable = !!this.#tcpRelays?.isFriendOnline(friendRealPk) ||
+            (!!dhtKeyForTcp && !!this.#tcpRelays?.isFriendOnline(dhtKeyForTcp));
         if (connectCandidates.length === 0 && !tcpAvailable) {
             this.#debugLog(`initiate session: no known endpoint for ${friendId} yet`);
             return false;
@@ -5354,8 +5361,28 @@ export class Peer {
             }
             // Also send via TCP relay if available, in parallel. Whichever
             // arrives at the friend first triggers their cookie response.
-            if (tcpAvailable && this.#tcpRelays) {
-                tcpSent = this.#tcpRelays.sendToFriend(friendRealPk, packet);
+            // Route/notify state at the relay is keyed by the key the FRIEND
+            // handshook the relay with — for natives that's their (rotated) DHT
+            // key, NOT their identity key. The old real-pk-only calls meant
+            // tcpAvailable was never true for a native and the routed send would
+            // have gone to a key the relay didn't know (tcp=0 forever while both
+            // ends sat on the same relay).
+            if (this.#tcpRelays) {
+                const tcpKey = session.friendDhtPublicKey ?? friendRealPk;
+                if (this.#tcpRelays.isFriendOnline(tcpKey) || this.#tcpRelays.isFriendOnline(friendRealPk)) {
+                    tcpSent = this.#tcpRelays.sendToFriend(tcpKey, packet);
+                    if (tcpSent === 0 && tcpKey !== friendRealPk) {
+                        tcpSent = this.#tcpRelays.sendToFriend(friendRealPk, packet);
+                    }
+                }
+                // OOB fallback: needs no route/cid — the relay forwards to any
+                // connected client by key, and toxcore's oob handler accepts cookie
+                // requests (0x18). This is exactly how the iOS side reaches US when
+                // only a shared relay exists; without the mirror-image our own
+                // initiation had no TCP path until a route linked.
+                if (tcpSent === 0) {
+                    tcpSent = this.#tcpRelays.sendOobToFriend(tcpKey, packet);
+                }
             }
             if (sent === 0 && tcpSent === 0 && selfSent === 0) {
                 throw new Error("no cookie request packet was sent");

package/package.json

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