whalibmob 5.5.21 → 5.5.23

package/lib/DeviceManager.js

@@ -1,6 +1,9 @@
 'use strict';
 
-const { BinaryNode } = require('./BinaryNode');
+const { BinaryNode }  = require('./BinaryNode');
+const { NodeCache }   = require('@cacheable/node-cache');
+
+const DEVICE_CACHE_TTL = '5m';
 
 // ─── JID helpers ─────────────────────────────────────────────────────────────
 
@@ -18,6 +21,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;
@@ -109,40 +134,105 @@ function parseBundleFromUserNode(userNode) {
 class DeviceManager {
   constructor(client) {
     this._client        = client;
-    // phone → Set<deviceId>  (populated after first usync)
-    this._deviceCache   = new Map();
+    // phone → deviceId[]  (TTL-based: expires after 5 min, triggers fresh usync)
+    this._deviceCache   = new NodeCache({ ttl: DEVICE_CACHE_TTL });
     // phone → Promise<jids[]>  (in-flight usync dedup)
     this._usyncInflight = new Map();
-    // own device list cache (populated once per connection)
-    this._ownDeviceJids = null;
+    // own device list cache + expiry timestamp (refreshed every 5 min)
+    this._ownDeviceJids   = null;
+    this._ownDeviceExpiry = 0;
+  }
+
+  // ─── NodeCache helper methods ─────────────────────────────────────────────
+  // _deviceCache stores deviceId arrays (not Sets) because NodeCache serialises
+  // values and Sets don't round-trip reliably.  All callers use these helpers.
+
+  _dcHas(key)       { return this._deviceCache.has(key); }
+  _dcGet(key)       { return this._deviceCache.get(key) || null; }   // number[] | null
+  _dcSet(key, arr)  { this._deviceCache.set(key, arr); }
+  _dcAdd(key, id) {
+    const arr = this._deviceCache.get(key) || [];
+    if (!arr.includes(id)) arr.push(id);
+    this._deviceCache.set(key, arr);
+  }
+  _dcEnsure(key) {
+    if (!this._deviceCache.has(key)) this._deviceCache.set(key, []);
+  }
+  _dcDel(keys) {
+    for (const k of keys) this._deviceCache.del(k);
+  }
+  _dcFlush() {
+    this._deviceCache.flushAll();
+    this._ownDeviceJids   = null;
+    this._ownDeviceExpiry = 0;
   }
 
   // ─── 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;
   }
 
@@ -160,8 +250,8 @@ class DeviceManager {
   // Only truly unknown phones trigger a network IQ.
 
   async _usyncGetDevices(phones) {
-    // Fast path: all phones cached
-    const uncached = phones.filter(p => !this._deviceCache.has(p));
+    // Fast path: all phones cached (TTL-based: NodeCache returns null for expired entries)
+    const uncached = phones.filter(p => !this._dcHas(p));
     if (uncached.length === 0) {
       return this._jidsFromCache(phones);
     }
@@ -188,8 +278,8 @@ class DeviceManager {
   _jidsFromCache(phones) {
     const jids = [];
     for (const p of phones) {
-      const devices = this._deviceCache.get(p);
-      if (devices && devices.size > 0) {
+      const devices = this._dcGet(p);
+      if (devices && devices.length > 0) {
         for (const dev of devices) jids.push(makeDeviceJid(p, dev));
       } else {
         jids.push(makeDeviceJid(p, 0));
@@ -198,54 +288,156 @@ 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;
+
+          this._dcEnsure(cachePhone);
+
+          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._dcAdd(cachePhone, devId);
+            }
+            process.stderr.write('[DBG] USYNC_DEVICES phone=' + cachePhone +
+              ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']\n');
+          } else {
+            // No device-list in response — fall back to device 0
+            this._dcAdd(cachePhone, 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]));
+      if (!this._dcHas(p)) {
+        this._dcSet(p, [0]);
+        process.stderr.write('[DBG] USYNC_FALLBACK phone=' + p + '\n');
       }
     }
   }
@@ -297,6 +489,219 @@ 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: skip usync ONLY if we already have a cache hit (i.e. we
+    // fetched this LID's devices in the last 5 min).  On a cache miss we MUST
+    // run a real usync even with skipUsync=true, otherwise linked devices (tablets,
+    // desktop, web) are silently ignored and only device 0 (primary phone) is used.
+    if (skipUsync) {
+      if (!this._dcHas(cacheKey)) {
+        process.stderr.write('[DBG] LID_SKIP_USYNC_CACHE_MISS lidUser=' + lidUser + ' → real usync\n');
+        await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
+      } else {
+        process.stderr.write('[DBG] LID_SKIP_USYNC_HIT lidUser=' + lidUser + ' → cache\n');
+      }
+    } else if (!this._dcHas(cacheKey)) {
+      await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
+    }
+
+    const deviceIds  = this._dcGet(cacheKey) || [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;
+    });
+
+    this._dcEnsure(cacheKey);
+
+    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._dcAdd(cacheKey, devId);
+            }
+            process.stderr.write('[DBG] USYNC_LID_DEVICES jid=' + jid +
+              ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']\n');
+          } else {
+            this._dcAdd(cacheKey, 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._dcAdd(cacheKey, 0);
+      }
+    } else {
+      process.stderr.write('[DBG] USYNC_LID_NULL_RESP jid=' + jid + '\n');
+      this._dcAdd(cacheKey, 0);
+    }
+  }
+
   // ─── Ensure sessions for own linked devices (device != 0) ─────────────────
   //
   // OPTIMISATION: own device list is cached for the entire connection lifetime.
@@ -304,15 +709,16 @@ class DeviceManager {
   //   from cache — zero extra network round-trips.
   //
   async ensureOwnDeviceSessions(ownPhone, signalProto, allowPkmsg = true) {
-    // If own device list is already cached, use it directly
-    if (this._ownDeviceJids !== null) {
+    // Use cached own device list if it hasn't expired (5-min TTL matches _deviceCache)
+    if (this._ownDeviceJids !== null && Date.now() < this._ownDeviceExpiry) {
       const others = this._ownDeviceJids.filter(j => stripUser(j).device !== 0);
       return this._ensureSessions(others, signalProto, allowPkmsg);
     }
 
-    // First call: query usync for own devices (same as before, but we cache the result)
-    const deviceJids   = await this._usyncGetDevices([ownPhone]);
-    this._ownDeviceJids = deviceJids;
+    // Cache miss or expired: re-query usync for own devices
+    const deviceJids      = await this._usyncGetDevices([ownPhone]);
+    this._ownDeviceJids   = deviceJids;
+    this._ownDeviceExpiry = Date.now() + 5 * 60 * 1000;
 
     const others = deviceJids.filter(j => stripUser(j).device !== 0);
     return this._ensureSessions(others, signalProto, allowPkmsg);
@@ -353,10 +759,9 @@ class DeviceManager {
   // ─── Invalidate cached device list (used on phash mismatch / 421 retry) ───
   clearCache(phones) {
     if (!phones || phones.length === 0) {
-      this._deviceCache.clear();
-      this._ownDeviceJids = null;
+      this._dcFlush();
     } else {
-      for (const p of phones) this._deviceCache.delete(p);
+      this._dcDel(phones);
     }
   }
 
@@ -365,7 +770,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 +782,4 @@ class DeviceManager {
   }
 }
 
-module.exports = { DeviceManager, makeDeviceJid, stripUser, phoneFromJid, parseBundleFromUserNode };
+module.exports = { DeviceManager, makeDeviceJid, stripUser, phoneFromJid, parseBundleFromUserNode, jidStrToObj };

package/lib/Registration.js

@@ -370,6 +370,7 @@ function toBase64Url(buf) {
 
 function buildPayload(store, waVersion, useToken, extraPairs) {
   const { cc, national } = parsePhone(store.phoneNumber);
+  const meta  = getCountryMeta(cc);
   const token = useToken ? computeToken(waVersion, national) : null;
   const fdid  = store.fdid.toUpperCase();
 
@@ -377,8 +378,8 @@ function buildPayload(store, waVersion, useToken, extraPairs) {
     'cc',         cc,
     'in',         national,
     'rc',         String(RELEASE_CHANNEL),
-    'lg',         'en',
-    'lc',         'US',
+    'lg',         meta.lg,
+    'lc',         meta.lc,
     'authkey',    toBase64Url(stripKeyPrefix(store.noiseKeyPair.public)),
     'e_regid',    toBase64Url(intToBytes(store.registrationId, 4)),
     'e_keytype',  toBase64Url(Buffer.from([SIGNAL_KEY_TYPE])),
@@ -601,11 +602,15 @@ async function requestSmsCode(store, method) {
   const fallbackMethod = method === 'wa_old' ? 'sms' : (method === 'sms' ? 'wa_old' : 'sms');
   let autoFallbackDone = false;
 
+  // Derive real MCC/MNC from the phone number being registered.
+  const { cc: _regCc } = parsePhone(store.phoneNumber);
+  const _regMeta       = getCountryMeta(_regCc);
+
   async function _tryMethod(m) {
     const extra = [
       'method',            m,
-      'sim_mcc',           '000',
-      'sim_mnc',           '000',
+      'sim_mcc',           _regMeta.mcc,
+      'sim_mnc',           _regMeta.mnc,
       'reason',            '',
       'cellular_strength', '1'
     ];
@@ -706,4 +711,4 @@ async function verifyCode(store, code) {
   throw new Error(`Verification failed: ${reason || JSON.stringify(result)}`);
 }
 
-module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, parsePhone, assertRegistrationKeys };
+module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, parsePhone, getCountryMeta, assertRegistrationKeys };