whalibmob 5.5.73 → 5.5.75

package/lib/DeviceManager.js

@@ -44,12 +44,18 @@ function jidStrToObj(jidStr) {
   if (server === 's.whatsapp.net' && device > 0) {
     return { user, agent: 0, device, server, toString() { return self; } };
   }
-  // @lid multi-device (e.g. "112713111982325:2@lid"): JID_PAIR with user="112713111982325:2"
-  // so the server receives the colon-device in the user string, not stripped.
-  // Without this, ":2@lid" is encoded as device-0 "@lid" and the server
-  // returns the wrong bundle (or ignores device 2 entirely).
+  // @lid multi-device (e.g. "112713111982325:2@lid"): AD_JID with the domain in
+  // the agent byte — 1 for lid, matching Baileys' writeJid, which emits AD_JID
+  // with domainType whenever a device is present.
+  //
+  // This previously packed the device into the user string as a JID_PAIR
+  // ("112713111982325:2"), a workaround from when the encoder could not express
+  // a LID agent at all and would otherwise have flattened the JID to device 0.
+  // The server does not recognise that shape: a prekey IQ addressed with it got
+  // no reply whatsoever and timed out, so no session was ever built for the
+  // contact's linked devices and sends failed with NO_OPEN_SESSION.
   if (server === 'lid' && device > 0) {
-    return { user: raw, server, toString() { return self; } };
+    return { user, agent: 1, device, server, toString() { return self; } };
   }
   // JID_PAIR: used for @lid device-0, @g.us, and primary (device-0) @s.whatsapp.net
   return { user, server, toString() { return self; } };
@@ -749,8 +755,37 @@ class DeviceManager {
     }
 
     if (allowPkmsg && fetchJids.length > 0) {
-      const bundles = await this.fetchBundles(fetchJids);
-      for (const [jid, bundle] of bundles) {
+      // Ask for the bundles by phone JID. The encrypt IQ is not answered at all
+      // when its <user> entries are @lid — it just times out — while the same
+      // request in phone form comes back in full. Translate through the known
+      // LID→PN mapping, keeping a link back so each bundle is installed under
+      // the LID address the participants node will use.
+      const pnForLid = this._client._lidToPn && this._client._lidToPn.get(lidUser);
+      const wireToLid = new Map();
+      let wireJids = fetchJids;
+      if (pnForLid) {
+        wireJids = fetchJids.map(j => {
+          const at    = j.indexOf('@');
+          const base  = at >= 0 ? j.slice(0, at) : j;
+          const colon = base.indexOf(':');
+          const dev   = colon >= 0 ? (parseInt(base.slice(colon + 1), 10) || 0) : 0;
+          const wire  = makeDeviceJid(pnForLid, dev, 's.whatsapp.net');
+          wireToLid.set(wire, j);
+          return wire;
+        });
+        _whaDbg('[DBG] LID_BUNDLE_VIA_PN lid=' + lidUser + ' pn=' + pnForLid +
+          ' jids=[' + wireJids.join(',') + ']\n');
+      } else {
+        _whaDbg('[DBG] LID_BUNDLE_NO_PN lid=' + lidUser + ' — requesting by LID\n');
+      }
+
+      const bundles = await this.fetchBundles(wireJids);
+      for (const [wireJid, bundle] of bundles) {
+        // Install under the @lid address: that is what the outgoing
+        // participants node — and therefore the encrypt step — looks the
+        // session up by. Stored under the phone user it is a different Signal
+        // address and would never be found.
+        const jid = wireToLid.get(wireJid) || wireJid;
         try {
           await signalProto.buildSessionFromBundle(jid, bundle);
           // ── CRITICAL: remap bundle JID back to @lid format ────────────────────
@@ -760,14 +795,13 @@ class DeviceManager {
           // nodes to also use @lid format — mixing @s.whatsapp.net participants with
           // a @lid routing address causes the server to close the connection.
           //
-          // The Signal session address is keyed only by (user, device) — the @server
-          // suffix is stripped by jidToAddress() — so the session is reachable via
-          // either @lid or @s.whatsapp.net.  We push the @lid form so the participants
-          // node is consistent with the routing.
-          //
-          // Mapping: strip @s.whatsapp.net / @lid suffix from jid, re-append @lid
-          // e.g. "112713111982325@s.whatsapp.net"   → "112713111982325@lid"
-          //      "112713111982325:2@s.whatsapp.net" → "112713111982325:2@lid"
+          // A Signal address is (user, device) with the @server stripped — but
+          // the user of a LID and the user of a phone JID are different strings,
+          // so a session is NOT reachable under both. That assumption is what
+          // left sends failing: bundles fetched in phone form were stored under
+          // the phone user while the participants node looked them up by LID.
+          // The session is installed under the @lid address above; this only
+          // normalises the JID pushed into readyJids.
           const jidBase = jid.replace(/@(?:s\.whatsapp\.net|lid)$/, '');
           const lidJidForDevice = jidBase + '@lid';
           readyJids.push(lidJidForDevice);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.5.73",
+  "version": "5.5.75",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",