whalibmob 5.5.21 → 5.5.22

package/lib/Client.js

@@ -175,6 +175,17 @@ class WhalibmobClient extends EventEmitter {
     this._signal = SignalProtocol.fromStore(this._store, signalFile, skFile);
     this._devMgr = new DeviceManager(this);
 
+    // Restore LID ↔ phone mappings persisted from previous sessions.
+    // This ensures we can route to LID JIDs even on fresh connections where no
+    // incoming message has yet populated _pnToLid during this session.
+    const persistedLid = this._signal.store.getLidMappings
+      ? this._signal.store.getLidMappings() : {};
+    for (const [phone, lid] of Object.entries(persistedLid)) {
+      this._pnToLid.set(phone, lid);
+      this._lidToPn.set(lid, phone);
+    }
+    process.stderr.write('[DBG] LID_RESTORED count=' + Object.keys(persistedLid).length + '\n');
+
     await this._connectSocket();
     return this;
   }
@@ -530,6 +541,10 @@ class WhalibmobClient extends EventEmitter {
       if (lidUser && pnUser && lidUser !== pnUser) {
         this._lidToPn.set(lidUser, pnUser);
         this._pnToLid.set(pnUser, lidUser);
+        // Persist so the mapping survives reconnects / process restarts
+        if (this._signal && this._signal.store && this._signal.store.setLidMapping) {
+          this._signal.store.setLidMapping(pnUser, lidUser);
+        }
       }
     }
     process.stderr.write('[DBG] _handleMessage from=' + from + ' participant=' + participant + ' senderPn=' + senderPn + ' id=' + id + '\n');
@@ -1196,6 +1211,8 @@ class WhalibmobClient extends EventEmitter {
             const pnUser = pPhone.split('@')[0].split(':')[0];
             this._lidToPn.set(lidUser, pnUser);
             this._pnToLid.set(pnUser, lidUser);
+            if (this._signal && this._signal.store && this._signal.store.setLidMapping)
+              this._signal.store.setLidMapping(pnUser, lidUser);
           }
         }
         // Case B: participant JID is a PN, lid attribute is their LID
@@ -1204,6 +1221,8 @@ class WhalibmobClient extends EventEmitter {
           const lidUser = pLid.split('@')[0].split(':')[0];
           this._lidToPn.set(lidUser, pnUser);
           this._pnToLid.set(pnUser, lidUser);
+          if (this._signal && this._signal.store && this._signal.store.setLidMapping)
+            this._signal.store.setLidMapping(pnUser, lidUser);
         }
         return { jid: pJid, role: pRole };
       });

package/lib/DeviceManager.js

@@ -18,6 +18,28 @@ function makeDeviceJid(user, device, server) {
   return `${user}:${device}@${server}`;
 }
 
+// Convert a JID string like "user@server" or "user:device@server" into the
+// BinaryNode JID object format so _writeJid() emits proper binary JID_PAIR /
+// AD_JID bytes instead of raw UTF-8.  The server requires binary JID encoding
+// for routing attributes — raw UTF-8 strings are silently ignored for @lid JIDs.
+function jidStrToObj(jidStr) {
+  const str    = typeof jidStr === 'string' ? jidStr : String(jidStr);
+  const at     = str.indexOf('@');
+  const raw    = at >= 0 ? str.slice(0, at) : str;
+  const server = at >= 0 ? str.slice(at + 1) : 's.whatsapp.net';
+  const colon  = raw.indexOf(':');
+  const user   = colon >= 0 ? raw.slice(0, colon) : raw;
+  const device = colon >= 0 ? (parseInt(raw.slice(colon + 1), 10) || 0) : 0;
+  const self   = str;
+  // AD_JID binary format requires both agent AND device fields — use only for
+  // multi-device @s.whatsapp.net JIDs where device > 0.
+  if (server === 's.whatsapp.net' && device > 0) {
+    return { user, agent: 0, device, server, toString() { return self; } };
+  }
+  // JID_PAIR: used for @lid, @g.us, and primary (device-0) @s.whatsapp.net
+  return { user, server, toString() { return self; } };
+}
+
 function phoneFromJid(jid) {
   const { user } = stripUser(jid);
   return user;
@@ -119,30 +141,70 @@ class DeviceManager {
 
   // ─── Fetch pre-key bundles for a list of JIDs via encrypt IQ ───────────────
   // Only called for JIDs where no Signal session exists yet.
-  // Returns Map<jid, bundle>
+  // Returns Map<string_jid, bundle> — keys are always normalised strings.
   async fetchBundles(jids) {
     if (!jids || jids.length === 0) return new Map();
 
-    const userNodes = jids.map(jid => { const lidMatch = jid.match(/(\d{15,})@s\.whatsapp\.net/); return new BinaryNode('user', { jid }, null); });
+    // Convert a string JID like "user@server" or "user:device@server" into
+    // a proper JID object so the binary encoder uses JID_PAIR / AD_JID format.
+    // Raw UTF-8 strings are NOT recognised by the WA server for @lid JIDs — the
+    // server silently ignores unknown JIDs and returns an empty bundle list.
+    const toJidObj = jidStr => {
+      const str    = typeof jidStr === 'string' ? jidStr : String(jidStr);
+      const at     = str.indexOf('@');
+      const raw    = at >= 0 ? str.slice(0, at) : str;
+      const server = at >= 0 ? str.slice(at + 1) : 's.whatsapp.net';
+      const colon  = raw.indexOf(':');
+      const user   = colon >= 0 ? raw.slice(0, colon) : raw;
+      const device = colon >= 0 ? (parseInt(raw.slice(colon + 1), 10) || 0) : 0;
+      const self   = str;
+      // AD_JID binary format is for @s.whatsapp.net with device > 0.
+      // JID_PAIR binary format is used for @lid and for device-0 @s.whatsapp.net.
+      if (server === 's.whatsapp.net' && device > 0) {
+        // AD_JID: agent=0, device=N
+        return { user, agent: 0, device, server, toString() { return self; } };
+      }
+      // JID_PAIR: user@server  — server may be 'lid' or 's.whatsapp.net'
+      return { user, server, toString() { return self; } };
+    };
+
+    const userNodes = jids.map(jid => new BinaryNode('user', { jid: toJidObj(jid) }, null));
     const iqId   = this._client._genMsgId();
     const iqNode = new BinaryNode('iq',
       { id: iqId, xmlns: 'encrypt', type: 'get', to: 's.whatsapp.net' },
       [new BinaryNode('key', {}, userNodes)]
     );
 
+    process.stderr.write('[DBG] FETCH_BUNDLES jids=[' + jids.join(',') + ']\n');
+
     const response = await this._client._sendIq(iqNode);
     const bundles  = new Map();
-    if (!response) return bundles;
+    if (!response) {
+      process.stderr.write('[DBG] FETCH_BUNDLES_NULL\n');
+      return bundles;
+    }
 
     const listNode = findChild(response, 'list');
     const children = listNode ? listNode.content : (response.content || []);
+
+    process.stderr.write('[DBG] FETCH_BUNDLES_RESP childCount=' +
+      (Array.isArray(children) ? children.length : 0) + '\n');
+
     for (const userNode of (Array.isArray(children) ? children : [])) {
       if (!userNode || userNode.description !== 'user') continue;
-      const jid = userNode.attrs && userNode.attrs.jid;
-      if (!jid) continue;
+      const jidRaw = userNode.attrs && userNode.attrs.jid;
+      if (!jidRaw) continue;
+      // Always normalise to a string key so Map lookups are consistent
+      const jidStr = String(jidRaw);
+      process.stderr.write('[DBG] FETCH_BUNDLES_USER jid=' + jidStr +
+        ' childTags=' + (Array.isArray(userNode.content)
+          ? userNode.content.map(c => c && c.description).filter(Boolean).join(',')
+          : '') + '\n');
       const bundle = parseBundleFromUserNode(userNode);
-      if (bundle) bundles.set(jid, bundle);
+      if (bundle) bundles.set(jidStr, bundle);
+      else process.stderr.write('[DBG] FETCH_BUNDLES_NO_BUNDLE jid=' + jidStr + '\n');
     }
+    process.stderr.write('[DBG] FETCH_BUNDLES_DONE count=' + bundles.size + '\n');
     return bundles;
   }
 
@@ -198,54 +260,158 @@ class DeviceManager {
     return jids.length > 0 ? jids : phones.map(p => makeDeviceJid(p, 0));
   }
 
-  // Actual usync IQ — only called for phones NOT in _deviceCache
+  // ─── FIXED usync IQ — corrects 4 bugs in the original implementation ────────
+  //
+  //  Bug 1 — Wrong <list> node format:
+  //    Was:  <user><contact>+phone</contact></user>
+  //    Fix:  <user jid="phone@s.whatsapp.net"/>     (jid ATTRIBUTE, not contact child)
+  //
+  //  Bug 2 — Wrong <query><devices> node:
+  //    Was:  <devices version="2"><device jid="phone@s.whatsapp.net"/></devices>
+  //    Fix:  <devices version="2"/>                  (NO device children in query)
+  //
+  //  Bug 3 — Missing <side_list/> node:
+  //    Was:  (absent)
+  //    Fix:  <side_list/>                            (required for LID device discovery)
+  //
+  //  Bug 4 — Wrong response parser:
+  //    Was:  deep walk looking for <device jid="..."> attrs
+  //    Fix:  navigate  usync → list → user[jid=...] → devices → device-list → device[id=N]
+  //          Server returns <device id="0"/>  NOT <device jid="..."/>
+  //          The phone/LID identifier is on the PARENT <user jid="..."> node, not on device.
+  //
   async _doUsyncIq(phones) {
     const iqId = this._client._genMsgId();
     const sid  = this._client._genMsgId();
 
+    // FIX Bug 1: jid attribute on <user>, not a <contact> child node
+    // FIX Bug 2: <devices version="2"/> with NO children
     const listChildren = phones.map(p =>
-      new BinaryNode('user', {},
-        [new BinaryNode('contact', {}, Buffer.from('+' + p))]
-      )
-    );
-    const deviceChildren = phones.map(p =>
-      new BinaryNode('device', { jid: makeDeviceJid(p, 0) }, null)
+      new BinaryNode('user', { jid: `${p}@s.whatsapp.net` }, null)
     );
 
     const iqNode = new BinaryNode('iq',
       { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
       [new BinaryNode('usync',
-        { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
         [
           new BinaryNode('query', {},
-            [new BinaryNode('devices', { version: '2' }, deviceChildren)]
+            [new BinaryNode('devices', { version: '2' }, null)]   // FIX Bug 2: null, not deviceChildren
           ),
-          new BinaryNode('list', {}, listChildren)
+          new BinaryNode('list', {}, listChildren),
+          new BinaryNode('side_list', {}, null)                    // FIX Bug 3: required node
         ]
       )]
     );
 
-    const response = await this._client._sendIq(iqNode).catch(() => null);
-
-    // Walk response and populate cache
-    const found = new Set();
-    function walk(node) {
-      if (!node) return;
-      if (node.description === 'device' && node.attrs && node.attrs.jid) {
-        const jid = node.attrs.jid;
-        const { user, device } = stripUser(jid);
-        if (!found.has(user)) found.add(user);
-        if (!this._deviceCache.has(user)) this._deviceCache.set(user, new Set());
-        this._deviceCache.get(user).add(device);
+    process.stderr.write('[DBG] USYNC_IQ phones=[' + phones.join(',') + ']\n');
+
+    const response = await this._client._sendIq(iqNode).catch(err => {
+      process.stderr.write('[DBG] USYNC_ERR ' + (err && err.message) + '\n');
+      return null;
+    });
+
+    // FIX Bug 4: Correct response structure is:
+    //   <usync>
+    //     <list>
+    //       <user jid="phone@s.whatsapp.net" [lid="lid_user@lid"]>
+    //         <devices>
+    //           <device-list>
+    //             <device id="0"/>
+    //             <device id="2"/>
+    //           </device-list>
+    //         </devices>
+    //       </user>
+    //     </list>
+    //   </usync>
+    if (response) {
+      const usyncNode = findChild(response, 'usync');
+      const listNode  = usyncNode
+        ? findChild(usyncNode, 'list')
+        : findChild(response, 'list');
+
+      if (listNode && Array.isArray(listNode.content)) {
+        for (const userNode of listNode.content) {
+          if (!userNode || userNode.description !== 'user') continue;
+
+          const userJid = userNode.attrs && (userNode.attrs.jid || userNode.attrs.value);
+          if (!userJid) continue;
+
+          const isLidUser = String(userJid).endsWith('@lid');
+          const { user: rawUser } = stripUser(String(userJid));
+
+          // Determine phone-based cache key (always a phone number, never a LID)
+          let cachePhone;
+          if (isLidUser) {
+            // Modern account: server returned LID JID in the user node
+            const pn = this._client._lidToPn && this._client._lidToPn.get(rawUser);
+            if (pn) {
+              cachePhone = pn;
+            } else if (phones.length === 1) {
+              // Single phone queried — this LID must belong to it
+              cachePhone = phones[0];
+              if (this._client._lidToPn) this._client._lidToPn.set(rawUser, phones[0]);
+              if (this._client._pnToLid) this._client._pnToLid.set(phones[0], rawUser);
+            } else {
+              cachePhone = rawUser; // last resort: use LID user as key
+            }
+            process.stderr.write('[DBG] USYNC_LID_USER userJid=' + userJid + ' → cachePhone=' + cachePhone + '\n');
+          } else {
+            // Normal account: user JID is phone@s.whatsapp.net
+            cachePhone = rawUser;
+
+            // Also extract LID from user node's `lid` attribute if the server provided it
+            const lidAttr = userNode.attrs && userNode.attrs.lid;
+            if (lidAttr) {
+              const lidUser = String(lidAttr).split('@')[0].split(':')[0];
+              if (this._client._lidToPn) this._client._lidToPn.set(lidUser, cachePhone);
+              if (this._client._pnToLid) this._client._pnToLid.set(cachePhone, lidUser);
+              process.stderr.write('[DBG] USYNC_LID_MAP phone=' + cachePhone + ' ↔ lid=' + lidUser + '\n');
+            }
+          }
+
+          // Navigate user → devices → device-list → device[id=N]
+          const devicesNode    = findChild(userNode, 'devices');
+          const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
+
+          if (!this._deviceCache.has(cachePhone)) {
+            this._deviceCache.set(cachePhone, new Set());
+          }
+
+          if (deviceListNode && Array.isArray(deviceListNode.content)) {
+            for (const devNode of deviceListNode.content) {
+              if (!devNode || devNode.description !== 'device') continue;
+              // FIX: server uses `id` attribute (e.g. id="0"), NOT `jid` attribute
+              const devId = devNode.attrs && devNode.attrs.id != null
+                ? parseInt(String(devNode.attrs.id), 10)
+                : 0;
+              this._deviceCache.get(cachePhone).add(devId);
+            }
+            process.stderr.write('[DBG] USYNC_DEVICES phone=' + cachePhone +
+              ' ids=[' + [...this._deviceCache.get(cachePhone)].join(',') + ']\n');
+          } else {
+            // No device-list in response — fall back to device 0
+            this._deviceCache.get(cachePhone).add(0);
+            process.stderr.write('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
+          }
+        }
+      } else {
+        process.stderr.write('[DBG] USYNC_RESP_NO_LIST\n');
       }
-      if (Array.isArray(node.content)) node.content.forEach(walk.bind(this));
+    } else {
+      process.stderr.write('[DBG] USYNC_NULL_RESP\n');
+      // Device usync timed out — fall back to a contact usync (query/contact).
+      // This DOES receive a server response and resolves the phone → LID mapping.
+      // Once _pnToLid is populated here, _sendDMMessage (after its await) will
+      // use the LID JID for routing instead of the stale phone JID.
+      await this._doContactUsync(phones).catch(() => {});
     }
-    if (response) walk.call(this, response);
 
-    // For any phone that returned no devices, cache device=0 so we don't query again
+    // For phones with no usync response at all, cache device 0 so we don't re-query
     for (const p of phones) {
       if (!this._deviceCache.has(p)) {
         this._deviceCache.set(p, new Set([0]));
+        process.stderr.write('[DBG] USYNC_FALLBACK phone=' + p + '\n');
       }
     }
   }
@@ -297,6 +463,217 @@ class DeviceManager {
     return readyJids;
   }
 
+  // ─── Ensure sessions for a LID-addressed recipient ────────────────────────
+  //
+  // For accounts migrated to WhatsApp LID, devices are registered under the
+  // LID identity (e.g. 139471160877194@lid), NOT the phone number.
+  // This method:
+  //   1. Queries usync for device list by LID JID
+  //   2. Establishes Signal sessions for LID device JIDs (e.g. 139471160877194:0@lid)
+  //   3. Returns the list of ready LID device JIDs for participant fanout
+  //
+  async bulkEnsureSessionsForLid(lidUser, signalProto, allowPkmsg = true, skipUsync = false) {
+    const lidJid    = `${lidUser}@lid`;
+    const cacheKey  = `lid:${lidUser}`;
+
+    // skipUsync=true: caller already knows the LID (from _pnToLid) — skip the
+    // usync round-trip and assume primary device 0.  Saves up to 15 s.
+    if (skipUsync) {
+      if (!this._deviceCache.has(cacheKey)) {
+        this._deviceCache.set(cacheKey, new Set([0]));
+        process.stderr.write('[DBG] LID_SKIP_USYNC lidUser=' + lidUser + ' assume device=0\n');
+      }
+    } else if (!this._deviceCache.has(cacheKey)) {
+      await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
+    }
+
+    const deviceIds  = this._deviceCache.get(cacheKey) || new Set([0]);
+    const deviceJids = [...deviceIds].map(d => makeDeviceJid(lidUser, d, 'lid'));
+
+    process.stderr.write('[DBG] LID_DEVICES lidUser=' + lidUser +
+      ' deviceJids=[' + deviceJids.join(',') + ']\n');
+
+    // Split: existing sessions (ready) vs new (need bundle fetch)
+    const readyJids = [];
+    const fetchJids = [];
+    for (const jid of deviceJids) {
+      if (signalProto.store.hasSession(this._jidToAddr(jid))) {
+        readyJids.push(jid);
+      } else {
+        fetchJids.push(jid);
+      }
+    }
+
+    if (allowPkmsg && fetchJids.length > 0) {
+      const bundles = await this.fetchBundles(fetchJids);
+      for (const [jid, bundle] of bundles) {
+        try {
+          await signalProto.buildSessionFromBundle(jid, bundle);
+          readyJids.push(jid);
+          process.stderr.write('[DBG] LID_SESSION_BUILT jid=' + jid + '\n');
+        } catch (e) {
+          process.stderr.write('[DBG] LID_SESSION_ERR jid=' + jid + ' err=' + e.message + '\n');
+        }
+      }
+    }
+
+    // Fallback: use primary LID device 0 directly (no session yet, will use pkmsg)
+    if (readyJids.length === 0) {
+      readyJids.push(makeDeviceJid(lidUser, 0, 'lid'));
+    }
+
+    return readyJids;
+  }
+
+  // ─── Contact usync fallback ────────────────────────────────────────────────
+  // When query/devices usync times out (server silently ignores it for LID
+  // accounts), we fall back to query/contact which uses the older
+  // <user><contact>+phone</contact></user> format and DOES get a response.
+  // The response includes the actual JID (LID or PN) for each phone.
+  // Calling this populates _pnToLid / _lidToPn in the Client, which is used
+  // by _sendDMMessage (checked AFTER the await of _usyncGetDevices).
+  async _doContactUsync(phones) {
+    const iqId = this._client._genMsgId();
+    const sid  = this._client._genMsgId();
+
+    const userNodes = phones.map(p =>
+      new BinaryNode('user', {}, [
+        new BinaryNode('contact', {}, Buffer.from('+' + p, 'utf8'))
+      ])
+    );
+
+    const iqNode = new BinaryNode('iq',
+      { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
+      [new BinaryNode('usync',
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
+        [
+          new BinaryNode('query', {}, [new BinaryNode('contact', {}, null)]),
+          new BinaryNode('list', {}, userNodes),
+          new BinaryNode('side_list', {}, null)
+        ]
+      )]
+    );
+
+    process.stderr.write('[DBG] CONTACT_USYNC phones=[' + phones.join(',') + ']\n');
+
+    const response = await this._client._sendIq(iqNode).catch(err => {
+      process.stderr.write('[DBG] CONTACT_USYNC_ERR ' + (err && err.message) + '\n');
+      return null;
+    });
+
+    if (!response) {
+      process.stderr.write('[DBG] CONTACT_USYNC_NULL\n');
+      return;
+    }
+
+    const usyncNode = findChild(response, 'usync');
+    const listNode  = usyncNode ? findChild(usyncNode, 'list') : findChild(response, 'list');
+
+    if (!listNode || !Array.isArray(listNode.content)) {
+      process.stderr.write('[DBG] CONTACT_USYNC_NO_LIST\n');
+      return;
+    }
+
+    for (let i = 0; i < listNode.content.length; i++) {
+      const userNode = listNode.content[i];
+      if (!userNode || userNode.description !== 'user') continue;
+
+      const actualJid = userNode.attrs && (userNode.attrs.jid || userNode.attrs.value);
+      if (!actualJid) continue;
+
+      const actualJidStr = String(actualJid);
+      const isLid = actualJidStr.endsWith('@lid');
+
+      if (isLid) {
+        const { user: lidUser } = stripUser(actualJidStr);
+        // Determine the corresponding phone.  For single-phone queries it's
+        // unambiguous; for multi-phone queries match by index.
+        const phone = phones.length === 1 ? phones[0] : phones[i];
+        if (phone) {
+          process.stderr.write('[DBG] CONTACT_USYNC_LID phone=' + phone + ' → lid=' + lidUser + '\n');
+          if (this._client._pnToLid) this._client._pnToLid.set(phone, lidUser);
+          if (this._client._lidToPn) this._client._lidToPn.set(lidUser, phone);
+          // Persist the mapping so future sessions don't need to re-query
+          const store = this._client._signal && this._client._signal.store;
+          if (store && store.setLidMapping) store.setLidMapping(phone, lidUser);
+        }
+      } else {
+        // PN account — note it (still on phone-based routing, no LID needed)
+        const { user: pnUser } = stripUser(actualJidStr);
+        const phone = phones.length === 1 ? phones[0] : phones[i];
+        process.stderr.write('[DBG] CONTACT_USYNC_PN phone=' + phone + ' jid=' + actualJidStr + '\n');
+      }
+    }
+  }
+
+  // ─── usync IQ for a specific JID (LID or phone-based) ─────────────────────
+  // Used when we already know the routing JID and want to look up devices for it.
+  async _doUsyncIqByJid(jid, cacheKey, lidUser) {
+    const iqId = this._client._genMsgId();
+    const sid  = this._client._genMsgId();
+
+    const iqNode = new BinaryNode('iq',
+      { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
+      [new BinaryNode('usync',
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
+        [
+          new BinaryNode('query', {},
+            [new BinaryNode('devices', { version: '2' }, null)]
+          ),
+          new BinaryNode('list', {},
+            [new BinaryNode('user', { jid }, null)]
+          ),
+          new BinaryNode('side_list', {}, null)
+        ]
+      )]
+    );
+
+    process.stderr.write('[DBG] USYNC_LID_IQ jid=' + jid + '\n');
+
+    const response = await this._client._sendIq(iqNode).catch(err => {
+      process.stderr.write('[DBG] USYNC_LID_IQ_ERR ' + (err && err.message) + '\n');
+      return null;
+    });
+
+    if (!this._deviceCache.has(cacheKey)) {
+      this._deviceCache.set(cacheKey, new Set());
+    }
+
+    if (response) {
+      const usyncNode = findChild(response, 'usync');
+      const listNode  = usyncNode ? findChild(usyncNode, 'list') : findChild(response, 'list');
+
+      if (listNode && Array.isArray(listNode.content)) {
+        for (const userNode of listNode.content) {
+          if (!userNode || userNode.description !== 'user') continue;
+
+          const devicesNode    = findChild(userNode, 'devices');
+          const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
+
+          if (deviceListNode && Array.isArray(deviceListNode.content)) {
+            for (const devNode of deviceListNode.content) {
+              if (!devNode || devNode.description !== 'device') continue;
+              const devId = devNode.attrs && devNode.attrs.id != null
+                ? parseInt(String(devNode.attrs.id), 10) : 0;
+              this._deviceCache.get(cacheKey).add(devId);
+            }
+            process.stderr.write('[DBG] USYNC_LID_DEVICES jid=' + jid +
+              ' ids=[' + [...this._deviceCache.get(cacheKey)].join(',') + ']\n');
+          } else {
+            this._deviceCache.get(cacheKey).add(0);
+            process.stderr.write('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
+          }
+        }
+      } else {
+        process.stderr.write('[DBG] USYNC_LID_NO_LIST jid=' + jid + '\n');
+        this._deviceCache.get(cacheKey).add(0);
+      }
+    } else {
+      process.stderr.write('[DBG] USYNC_LID_NULL_RESP jid=' + jid + '\n');
+      this._deviceCache.get(cacheKey).add(0);
+    }
+  }
+
   // ─── Ensure sessions for own linked devices (device != 0) ─────────────────
   //
   // OPTIMISATION: own device list is cached for the entire connection lifetime.
@@ -365,7 +742,11 @@ class DeviceManager {
     const toNodes = encryptedList.map(({ jid, type, ciphertext }) => {
       const encAttrs = { type, v: '2' };
       if (mediaSubtype) encAttrs.mediatype = mediaSubtype;
-      return new BinaryNode('to', { jid },
+      // Always encode the jid as a binary JID object (JID_PAIR / AD_JID) so the
+      // server can route the per-device enc payload to the correct Signal session.
+      // Raw UTF-8 strings are silently dropped for @lid recipients.
+      const jidAttr = jidStrToObj(jid);
+      return new BinaryNode('to', { jid: jidAttr },
         [new BinaryNode('enc', encAttrs, ciphertext)]
       );
     });
@@ -373,4 +754,4 @@ class DeviceManager {
   }
 }
 
-module.exports = { DeviceManager, makeDeviceJid, stripUser, phoneFromJid, parseBundleFromUserNode };
+module.exports = { DeviceManager, makeDeviceJid, stripUser, phoneFromJid, parseBundleFromUserNode, jidStrToObj };

package/lib/messages/MessageSender.js

@@ -4,7 +4,7 @@ const crypto   = require('crypto');
 const path     = require('path');
 const fs       = require('fs');
 const { BinaryNode }  = require('../BinaryNode');
-const { DeviceManager } = require('../DeviceManager');
+const { DeviceManager, jidStrToObj } = require('../DeviceManager');
 const {
   encodeMessage,
   encodeText, encodeImageMessage, encodeVideoMessage,
@@ -553,12 +553,42 @@ class MessageSender {
     // Primary devices can always use pkmsg to establish new Signal sessions —
     // they simply omit the device-identity node (server accepts this for primaries).
     const allowPkmsg = true;
-    const [recipientDevices, ownDevices] = await Promise.all([
+
+    // First, run the phone-based usync (and own devices) in parallel.
+    // IMPORTANT: _pnToLid may be empty RIGHT NOW but gets populated during this
+    // await — incoming messages from the recipient (which arrive while we wait
+    // for the usync timeout) tell us their LID JID via from=LID + sender_pn attrs.
+    // We therefore check _pnToLid AFTER this await, not before.
+    const [_recipientDevicesByPhone, ownDevices] = await Promise.all([
       this._devMgr.bulkEnsureSessions([recipientPhone], this._signal, allowPkmsg),
       this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal, allowPkmsg)
     ]);
 
-    const otherJids     = recipientDevices.length > 0 ? recipientDevices : [toJid];
+    // ── LID routing fix ───────────────────────────────────────────────────────
+    // Check _pnToLid NOW — after the await above, incoming messages from the
+    // recipient during the usync wait will have populated this map.
+    // For LID-migrated accounts, the message `to` field AND Signal participants
+    // must use the LID JID.  Phone-JID messages are silently accepted by the
+    // server but never delivered to the recipient's LID-registered device.
+    const lidUser      = this._client._pnToLid && this._client._pnToLid.get(recipientPhone);
+    const routingToJid = lidUser ? `${lidUser}@lid` : toJid;
+
+    process.stderr.write('[DBG] DM_ROUTE phone=' + recipientPhone +
+      ' routing=' + routingToJid + (lidUser ? ' (LID)' : ' (PN)') + '\n');
+
+    let otherJids;
+    if (lidUser) {
+      // Fetch bundle + build Signal session for the LID JID.
+      // skipUsync=true: we already know the LID from _pnToLid — skip a second
+      // 15 s usync round-trip and go straight to bundle fetch (device 0 primary).
+      const lidDevices = await this._devMgr.bulkEnsureSessionsForLid(
+        lidUser, this._signal, allowPkmsg, /* skipUsync */ true);
+      otherJids = lidDevices.length > 0 ? lidDevices : [routingToJid];
+    } else {
+      otherJids = _recipientDevicesByPhone.length > 0 ? _recipientDevicesByPhone : [toJid];
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     const ownLinkedJids = ownDevices.filter(j => j !== ownMainJid);
 
     const allParticipants = [...otherJids, ...ownLinkedJids];
@@ -577,7 +607,10 @@ class MessageSender {
 
     const encryptedList = [...otherEncrypted, ...ownEncrypted];
 
-    const stanzaAttrs = { to: toJid, id: msgId, type: mediaType, t: String(msNow()) };
+    // Encode the routing JID as a binary JID object (JID_PAIR for @lid / @s.whatsapp.net).
+    // Raw UTF-8 strings are not recognised by the server for LID recipients, causing
+    // the message to be accepted (server ACK) but never delivered to the device.
+    const stanzaAttrs = { to: jidStrToObj(routingToJid), id: msgId, type: mediaType, t: String(msNow()) };
     if (phash) stanzaAttrs.phash = phash;
     if (options.edit) stanzaAttrs.edit = String(options.edit);
 
@@ -599,6 +632,19 @@ class MessageSender {
 
     const msgNode = new BinaryNode('message', stanzaAttrs, msgContent);
 
+    // Debug: log outgoing stanza details
+    process.stderr.write('[DBG] DM_SEND to=' + toJid +
+      ' otherJids=[' + otherJids.join(',') + ']' +
+      ' ownLinked=[' + ownLinkedJids.join(',') + ']' +
+      ' encrypted=' + encryptedList.length +
+      ' hasPkmsg=' + hasPkmsg +
+      ' hasAdv=' + !!(advBytes) +
+      '\n');
+    if (encryptedList.length > 0) {
+      process.stderr.write('[DBG] DM_PARTICIPANTS ' +
+        encryptedList.map(e => e.jid + '(' + e.type + ')').join(', ') + '\n');
+    }
+
     // Cache plaintext so Client can re-send with fresh session on recipient retry
     if (this._client._sentMsgCache) {
       this._client._sentMsgCache.set(msgId, {
@@ -699,7 +745,7 @@ class MessageSender {
     msgContent.push(new BinaryNode('enc', skmsgAttrs, Buffer.isBuffer(skmsgCiphertext) ? skmsgCiphertext : Buffer.from(skmsgCiphertext)));
 
     const stanzaAttrs = {
-      to: groupJid,
+      to: jidStrToObj(groupJid),
       id: msgId,
       type: mediaType,
       addressing_mode: groupAddressingMode,

package/lib/signal/SignalStore.js

@@ -26,6 +26,7 @@ class SignalStore {
     this._signedPreKeys    = {};
     this._identities       = {};
     this._filePath         = null;
+    this._lidMappings      = {};   // phone → lid — persisted alongside sessions
 
     // Debounce state
     this._dirty            = false;
@@ -56,9 +57,24 @@ class SignalStore {
       this._preKeys       = raw.preKeys       || {};
       this._signedPreKeys = raw.signedPreKeys || {};
       this._identities    = raw.identities    || {};
+      this._lidMappings   = raw.lidMappings   || {};  // phone → lid, persisted
     } catch (_) {}
   }
 
+  // Persist a phone ↔ LID mapping.  Called any time we learn a new mapping from
+  // incoming messages or from a contact usync fallback query.
+  setLidMapping(phone, lid) {
+    if (!phone || !lid) return;
+    if (this._lidMappings[phone] === lid) return; // already stored, skip disk write
+    this._lidMappings[phone] = lid;
+    this._save();
+  }
+
+  // Return all stored phone → lid mappings (used to populate Client._pnToLid on startup)
+  getLidMappings() {
+    return this._lidMappings;
+  }
+
   // Immediate synchronous flush (used on process exit only)
   _flushSync() {
     if (!this._dirty || !this._filePath) return;
@@ -68,7 +84,8 @@ class SignalStore {
         sessions:      this._sessions,
         preKeys:       this._preKeys,
         signedPreKeys: this._signedPreKeys,
-        identities:    this._identities
+        identities:    this._identities,
+        lidMappings:   this._lidMappings
       });
       const dir = path.dirname(this._filePath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -89,7 +106,8 @@ class SignalStore {
         sessions:      this._sessions,
         preKeys:       this._preKeys,
         signedPreKeys: this._signedPreKeys,
-        identities:    this._identities
+        identities:    this._identities,
+        lidMappings:   this._lidMappings
       });
       const dir = path.dirname(this._filePath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });

package/package.json

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

package/.env.example

@@ -1,49 +0,0 @@
-# ─────────────────────────────────────────────────────────────────────────────
-# whalibmob — Device Emulation Configuration
-# Copy this file to .env in your project root and set the values you need.
-# All variables are optional; defaults emulate an iPhone 15 Pro running iOS 17.
-# ─────────────────────────────────────────────────────────────────────────────
-
-# Operating system to emulate.  Accepted values: ios | android
-# Default: ios
-# WA_OS=android
-
-# Named device profile.
-#
-# iOS profiles (WA_OS=ios):
-#   iphone_15_pro, iphone_15, iphone_14_pro, iphone_14, iphone_13_pro,
-#   iphone_13, iphone_12_pro, iphone_12, iphone_11_pro, iphone_11,
-#   iphone_se3, iphone_xs
-#
-# Android profiles (WA_OS=android):
-#   pixel_8_pro, pixel_8, pixel_7, pixel_7a,
-#   samsung_s24_ultra, samsung_s24, samsung_s23_ultra, samsung_s23, samsung_a55,
-#   oneplus_12, oneplus_11, xiaomi_14, xiaomi_13, oppo_find_x7, realme_gt5
-#
-# Default: iphone_15_pro  (or pixel_8_pro when WA_OS=android)
-# WA_DEVICE=pixel_8_pro
-
-# ── Custom device overrides (applied on top of the selected profile) ─────────
-# Use these to fine-tune any field without creating a new profile.
-
-# WA_DEVICE_MODEL=SM-S928B
-# WA_DEVICE_MANUFACTURER=samsung
-# WA_DEVICE_OS_VERSION=14
-# WA_DEVICE_BUILD=UP1A.231005.007
-# WA_DEVICE_MODEL_ID=samsung-sm-s928b
-
-# ── Version & token overrides ─────────────────────────────────────────────────
-
-# Pin the WhatsApp version string instead of fetching the latest from the store.
-# Format: 2.x.x.x  (four-part)
-# WA_VERSION=2.24.13.80
-
-# Override the static token used in registration token computation.
-# Only needed if WhatsApp rotates the bundled token.
-# WA_STATIC_TOKEN=Y29Cs6AVNR2bj5PBeKSYFd1nAKuvNQ3h
-
-# ── Proxy / Tor ───────────────────────────────────────────────────────────────
-
-# Route registration HTTP traffic through a SOCKS5 proxy or Tor.
-# TOR_PROXY=socks5://127.0.0.1:9050
-# SOCKS_PROXY=socks5://user:pass@proxy.example.com:1080