whalibmob 5.1.17 → 5.1.19

package/lib/Client.js

@@ -103,6 +103,27 @@ function toSignalKey(raw) {
   return Buffer.from(raw);
 }
 
+// ─── JID helpers ─────────────────────────────────────────────────────────────
+
+// Convert a BinaryNode JID value to its canonical string form.
+// BinaryNode's _readAdJid() returns an object { user, agent, device, server }
+// with a toString() that yields "user@s.whatsapp.net".  For LID-mode group
+// participants those objects represent LID identifiers and must be stored as
+// "user@lid" so the rest of the code can detect them with endsWith('@lid').
+// Regular pair-JIDs ({ user, server, toString }) are returned verbatim.
+function _adJidToLid(jidVal) {
+  if (!jidVal) return '';
+  // AD JID objects (from _readAdJid) have an `agent` property — these are LIDs
+  if (typeof jidVal === 'object' && 'agent' in jidVal) {
+    return (jidVal.user || '') + '@lid';
+  }
+  // Pair JID objects (from _readJidPair) have user + server but no agent
+  if (typeof jidVal === 'object' && 'server' in jidVal) {
+    return jidVal.user ? `${jidVal.user}@${jidVal.server}` : `@${jidVal.server}`;
+  }
+  return String(jidVal);
+}
+
 // ─── WhalibmobClient ──────────────────────────────────────────────────────────
 
 class WhalibmobClient extends EventEmitter {
@@ -128,6 +149,7 @@ class WhalibmobClient extends EventEmitter {
     this._lidToPn          = new Map();   // LID user → phone number
     this._pnToLid          = new Map();   // phone number → LID user
     this._myLid            = null;        // own LID JID received from <success> node
+    this._myLidAgent       = 0;           // agent field from own LID JID (usually 1)
     this._groupAddressingMode = new Map(); // groupJid → 'lid' | 'pn'
     this._retryPending     = new Map();   // msgId → {node, retryCount}
     this._retryPreKeyIdx   = 0;           // rotating index for assigning unique prekeys to retries
@@ -284,7 +306,10 @@ class WhalibmobClient extends EventEmitter {
       }
     }
     if (attrs.platform) this._platform = attrs.platform;
-    if (attrs.lid)      this._myLid    = String(attrs.lid);
+    if (attrs.lid) {
+      this._myLid      = _adJidToLid(attrs.lid);
+      this._myLidAgent = (typeof attrs.lid === 'object' && attrs.lid.agent) ? attrs.lid.agent : 0;
+    }
 
     const devIdNode = findChild(node, 'device-identity');
     if (devIdNode) {
@@ -797,6 +822,9 @@ class WhalibmobClient extends EventEmitter {
     const cls    = attrs.class || '';
 
     if (cls === 'message') {
+      if (attrs.error) {
+        process.stderr.write('[DBG] ACK_ERR full node=' + JSON.stringify(node, (k,v) => Buffer.isBuffer(v) ? '<buf>' : v) + '\n');
+      }
       const handler = this._pendingAcks.get(id);
       if (handler) {
         this._pendingAcks.delete(id);
@@ -1184,12 +1212,17 @@ class WhalibmobClient extends EventEmitter {
     const participants = children
       .filter(n => n && n.description === 'participant' && n.attrs && n.attrs.jid)
       .map(n => {
-        const pJid  = String(n.attrs.jid);
+        // AD JID objects (LID participants) have an `agent` property → convert to @lid form
+        const pJid  = _adJidToLid(n.attrs.jid);
         const pRole = n.attrs.type || 'member';
-        const pPhone = n.attrs.phone_number ? String(n.attrs.phone_number) : null;
-        const pLid   = n.attrs.lid          ? String(n.attrs.lid)          : null;
+        // phone_number may also be a JID object → extract user part (PN without server)
+        const rawPhone = n.attrs.phone_number;
+        const pPhone = rawPhone
+          ? (typeof rawPhone === 'object' ? rawPhone.user : String(rawPhone).split('@')[0])
+          : null;
+        const pLid   = n.attrs.lid ? _adJidToLid(n.attrs.lid) : null;
         // Populate LID↔PN maps from participant attributes
-        // Case A: participant JID is a LID, phone_number is their PN
+        // Case A: participant JID is a LID (ends with @lid), phone_number is their PN
         if (pJid.endsWith('@lid')) {
           const lidUser = pJid.split('@')[0].split(':')[0];
           if (pPhone) {
@@ -1297,12 +1330,18 @@ class WhalibmobClient extends EventEmitter {
     const response = await this._sendIq(node);
     if (!response) return [];
 
-    // Response content is a list of <group> nodes
-    const children = Array.isArray(response.content) ? response.content : [];
-    const groups = children
-      .filter(n => n && n.description === 'group')
-      .map(n => this._parseGroupNode(n))
-      .filter(Boolean);
+    // Response structure: <iq><groups><group/><group/>...</groups></iq>
+    // Unwrap the <groups> container first, then collect <group> nodes
+    const iqChildren = Array.isArray(response.content) ? response.content : [];
+    let groupNodes = [];
+    const groupsWrapper = iqChildren.find(n => n && n.description === 'groups');
+    if (groupsWrapper && Array.isArray(groupsWrapper.content)) {
+      groupNodes = groupsWrapper.content.filter(n => n && n.description === 'group');
+    } else {
+      // Fallback: direct <group> children (older protocol variant)
+      groupNodes = iqChildren.filter(n => n && n.description === 'group');
+    }
+    const groups = groupNodes.map(n => this._parseGroupNode(n)).filter(Boolean);
     return groups;
   }
 

package/lib/DeviceManager.js

@@ -5,17 +5,24 @@ const { BinaryNode } = require('./BinaryNode');
 // ─── JID helpers ─────────────────────────────────────────────────────────────
 
 function stripUser(jid) {
-  const at    = jid.indexOf('@');
-  const user  = at >= 0 ? jid.slice(0, at) : jid;
-  const colon = user.indexOf(':');
-  if (colon >= 0) return { user: user.slice(0, colon), device: parseInt(user.slice(colon + 1), 10) };
-  return { user, device: 0 };
+  const at     = jid.indexOf('@');
+  const full   = at >= 0 ? jid.slice(0, at) : jid;
+  const colon  = full.indexOf(':');
+  const base   = colon >= 0 ? full.slice(0, colon) : full;
+  const device = colon >= 0 ? parseInt(full.slice(colon + 1), 10) : 0;
+  const under  = base.lastIndexOf('_');
+  if (under >= 0 && /^\d+$/.test(base.slice(under + 1))) {
+    return { user: base.slice(0, under), agent: parseInt(base.slice(under + 1), 10), device };
+  }
+  return { user: base, agent: 0, device };
 }
 
-function makeDeviceJid(user, device, server) {
+function makeDeviceJid(user, device, server, agent) {
   server = server || 's.whatsapp.net';
-  if (!device || device === 0) return `${user}@${server}`;
-  return `${user}:${device}@${server}`;
+  agent  = agent  || 0;
+  const agentStr = agent !== 0 ? `_${agent}` : '';
+  if (!device || device === 0) return `${user}${agentStr}@${server}`;
+  return `${user}${agentStr}:${device}@${server}`;
 }
 
 function phoneFromJid(jid) {
@@ -123,7 +130,22 @@ class DeviceManager {
   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); });
+    // Build proper JID objects for binary encoding.  Passing a plain string produces a raw
+    // bytes attribute, but the server requires a binary-encoded JID (JID_PAIR or AD_JID).
+    // E.g. "112713111982325_1:86@s.whatsapp.net" → { user:"112713111982325", agent:1, device:86, server:"s.whatsapp.net" }
+    const userNodes = jids.map(jid => {
+      const atIdx    = jid.indexOf('@');
+      const server   = atIdx >= 0 ? jid.slice(atIdx + 1) : 's.whatsapp.net';
+      const userPart = atIdx >= 0 ? jid.slice(0, atIdx) : jid;
+      const colonIdx = userPart.indexOf(':');
+      const base     = colonIdx >= 0 ? userPart.slice(0, colonIdx) : userPart;
+      const device   = colonIdx >= 0 ? parseInt(userPart.slice(colonIdx + 1), 10) : 0;
+      const underIdx = base.lastIndexOf('_');
+      const hasAgent = underIdx >= 0 && /^\d+$/.test(base.slice(underIdx + 1));
+      const user     = hasAgent ? base.slice(0, underIdx) : base;
+      const agent    = hasAgent ? parseInt(base.slice(underIdx + 1), 10) : 0;
+      return new BinaryNode('user', { jid: { user, agent: agent || 0, device: device || 0, server } }, null);
+    });
     const iqId   = this._client._genMsgId();
     const iqNode = new BinaryNode('iq',
       { id: iqId, xmlns: 'encrypt', type: 'get', to: 's.whatsapp.net' },
@@ -138,10 +160,28 @@ class DeviceManager {
     const children = listNode ? listNode.content : (response.content || []);
     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 rawJid = userNode.attrs && userNode.attrs.jid;
+      if (!rawJid) continue;
+      // Convert the binary JID object to a canonical string "user_agent:device@server"
+      let jidKey;
+      if (typeof rawJid === 'string') {
+        jidKey = rawJid;
+      } else {
+        const u  = rawJid.user   || '';
+        const ag = rawJid.agent  || 0;
+        const dv = rawJid.device || 0;
+        const sv = rawJid.server || 's.whatsapp.net';
+        const agStr = ag !== 0 ? `_${ag}` : '';
+        const dvStr = dv !== 0 ? `:${dv}` : '';
+        jidKey = `${u}${agStr}${dvStr}@${sv}`;
+      }
       const bundle = parseBundleFromUserNode(userNode);
-      if (bundle) bundles.set(jid, bundle);
+      if (bundle) {
+        process.stderr.write('[DBG] BUNDLE jid=' + jidKey + ' regId=' + bundle.registrationId + ' preKeyId=' + (bundle.preKey && bundle.preKey.keyId) + ' spkId=' + (bundle.signedPreKey && bundle.signedPreKey.keyId) + '\n');
+        bundles.set(jidKey, bundle);
+      } else {
+        process.stderr.write('[DBG] BUNDLE_FAIL jid=' + jidKey + ' no bundle parsed\n');
+      }
     }
     return bundles;
   }
@@ -199,17 +239,17 @@ class DeviceManager {
   }
 
   // Actual usync IQ — only called for phones NOT in _deviceCache
+  // Uses the mobile API format (cobalt-compatible):
+  //   <list> uses <user jid="phone@s.whatsapp.net"/> (not <user><contact>+phone</contact></user>)
+  //   <query> uses empty <devices version="2"/> (no individual <device> children)
+  //   Includes <side_list/> sibling required by the mobile API
   async _doUsyncIq(phones) {
     const iqId = this._client._genMsgId();
     const sid  = this._client._genMsgId();
 
+    // Mobile-API format: <user jid="{user}@s.whatsapp.net"/> as JID pair object
     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: { user: String(p), server: 's.whatsapp.net' } }, null)
     );
 
     const iqNode = new BinaryNode('iq',
@@ -218,34 +258,77 @@ class DeviceManager {
         { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
         [
           new BinaryNode('query', {},
-            [new BinaryNode('devices', { version: '2' }, deviceChildren)]
+            [new BinaryNode('devices', { version: '2' }, null)]
           ),
-          new BinaryNode('list', {}, listChildren)
+          new BinaryNode('list',      {}, listChildren),
+          new BinaryNode('side_list', {}, null)
         ]
       )]
     );
 
     const response = await this._client._sendIq(iqNode).catch(() => null);
+    process.stderr.write('[DBG] _doUsyncIq phones=' + phones.join(',') + ' response=' + (response ? response.description : 'null') + '\n');
+    if (!response) {
+      // Timeout: cache device=0 as fallback
+      for (const p of phones) {
+        if (!this._deviceCache.has(p)) this._deviceCache.set(p, new Set([0]));
+      }
+      return;
+    }
+
+    // Cobalt response structure:
+    // <iq><usync><list><user jid="..."><devices><device-list><device id="N"/></device-list></devices></user></list></usync></iq>
+    this._parseUsyncResponse(response, phones);
+  }
 
-    // Walk response and populate cache
-    const found = new Set();
+  // Parse a usync IQ response (works for both PN and LID usync)
+  // Populates _deviceCache: phone/user → Set<deviceId>
+  _parseUsyncResponse(response, expectedUsers) {
+    const self = this;
+    function walkUser(userNode) {
+      const rawJid = userNode.attrs && userNode.attrs.jid;
+      if (!rawJid) return;
+      process.stderr.write('[DBG] _parseUsyncResponse walkUser rawJid=' + JSON.stringify(rawJid) + '\n');
+      const user = typeof rawJid === 'object' ? rawJid.user : String(rawJid).split('@')[0];
+      if (!user) return;
+
+      // Look for <devices><device-list><device id="N"/>
+      const devicesNode = Array.isArray(userNode.content)
+        ? userNode.content.find(n => n && n.description === 'devices') : null;
+      if (!devicesNode || !Array.isArray(devicesNode.content)) {
+        // No devices node: still cache device=0 so we don't query again
+        if (!self._deviceCache.has(user)) self._deviceCache.set(user, new Set([0]));
+        return;
+      }
+      const deviceListNode = devicesNode.content.find(n => n && n.description === 'device-list');
+      const deviceNodes    = (deviceListNode && Array.isArray(deviceListNode.content))
+        ? deviceListNode.content.filter(n => n && n.description === 'device')
+        : [];
+
+      if (!self._deviceCache.has(user)) self._deviceCache.set(user, new Set());
+      const devSet = self._deviceCache.get(user);
+      if (deviceNodes.length === 0) {
+        devSet.add(0);
+      } else {
+        for (const dn of deviceNodes) {
+          const devId = parseInt((dn.attrs && dn.attrs.id) || '0', 10);
+          devSet.add(isNaN(devId) ? 0 : devId);
+        }
+      }
+    }
+
+    // Walk: iq → usync → list → user
     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);
-      }
-      if (Array.isArray(node.content)) node.content.forEach(walk.bind(this));
+      if (node.description === 'user') { walkUser(node); return; }
+      if (Array.isArray(node.content)) node.content.forEach(walk);
     }
-    if (response) walk.call(this, response);
+    walk(response);
 
-    // For any phone that returned no devices, cache device=0 so we don't query again
-    for (const p of phones) {
-      if (!this._deviceCache.has(p)) {
-        this._deviceCache.set(p, new Set([0]));
+    // Ensure any expected user not seen in response gets device=0 cached
+    if (expectedUsers) {
+      for (const u of expectedUsers) {
+        if (!self._deviceCache.has(u)) self._deviceCache.set(u, new Set([0]));
       }
     }
   }
@@ -350,6 +433,166 @@ class DeviceManager {
     return `${user}.${device}`;
   }
 
+  // ─── usync device list query by full JID (LID or PN) ─────────────────────
+  //
+  // Used for LID-mode group members that have no LID→PN mapping in _lidToPn.
+  // Sends <user jid="..."/> nodes directly instead of <user><contact>+phone</contact></user>,
+  // which allows the server to resolve devices for LID JIDs natively.
+  //
+  async _usyncGetDevicesByJid(jids) {
+    if (!jids || jids.length === 0) return [];
+
+    const iqId = this._client._genMsgId();
+    const sid  = this._client._genMsgId();
+
+    // Build proper JID objects for each input JID (e.g. "112713111982325@lid")
+    const listChildren = jids.map(jidStr => {
+      const at     = jidStr.indexOf('@');
+      const user   = at >= 0 ? jidStr.slice(0, at)   : jidStr;
+      const server = at >= 0 ? jidStr.slice(at + 1)  : 's.whatsapp.net';
+      return new BinaryNode('user', { jid: { user, server } }, 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' },
+        [
+          new BinaryNode('query', {},
+            [new BinaryNode('devices', { version: '2' }, null)]
+          ),
+          new BinaryNode('list',      {}, listChildren),
+          new BinaryNode('side_list', {}, null)
+        ]
+      )]
+    );
+
+    const response = await this._client._sendIq(iqNode).catch(() => null);
+
+    if (!response) {
+      process.stderr.write('[DBG] _usyncGetDevicesByJid TIMEOUT for jids=' + jids.join(',') + '\n');
+      // Fallback: return main device for each input JID
+      return jids.map(j => {
+        const { user } = stripUser(j);
+        const server   = j.includes('@lid') ? 'lid' : 's.whatsapp.net';
+        return `${user}@${server}`;
+      });
+    }
+
+    // Parse response: collect (user, deviceId) pairs → build device JID strings
+    // Response structure: <iq><usync><list><user jid="..."><devices><device-list><device id="N"/></device-list></devices></user></list></usync></iq>
+    const foundJids = [];
+    function walkUser(userNode) {
+      const rawJid = userNode.attrs && userNode.attrs.jid;
+      if (!rawJid) return;
+      process.stderr.write('[DBG] walkUser rawJid=' + JSON.stringify(rawJid) + '\n');
+      const user     = typeof rawJid === 'object' ? rawJid.user   : String(rawJid).split('@')[0];
+      const server   = typeof rawJid === 'object' ? rawJid.server : (String(rawJid).split('@')[1] || 's.whatsapp.net');
+      const agent    = typeof rawJid === 'object' ? (rawJid.agent || 0) : 0;
+      const agentStr = agent !== 0 ? `_${agent}` : '';
+      if (!user) return;
+
+      const devicesNode    = Array.isArray(userNode.content) ? userNode.content.find(n => n && n.description === 'devices') : null;
+      const deviceListNode = devicesNode && Array.isArray(devicesNode.content) ? devicesNode.content.find(n => n && n.description === 'device-list') : null;
+      const deviceNodes    = deviceListNode && Array.isArray(deviceListNode.content) ? deviceListNode.content.filter(n => n && n.description === 'device') : [];
+
+      if (deviceNodes.length === 0) {
+        foundJids.push(`${user}${agentStr}@${server}`);
+      } else {
+        for (const dn of deviceNodes) {
+          const devId = parseInt((dn.attrs && dn.attrs.id) || '0', 10);
+          const dev   = isNaN(devId) ? 0 : devId;
+          foundJids.push(dev === 0 ? `${user}${agentStr}@${server}` : `${user}${agentStr}:${dev}@${server}`);
+        }
+      }
+    }
+    function walk(node) {
+      if (!node) return;
+      if (node.description === 'user') { walkUser(node); return; }
+      if (Array.isArray(node.content)) node.content.forEach(walk);
+    }
+    walk(response);
+
+    process.stderr.write('[DBG] _usyncGetDevicesByJid jids=' + jids.length + ' found=' + foundJids.length + ' ' + foundJids.join(',') + '\n');
+
+    // Fallback: if server returned nothing, use the main device JID for each input
+    if (foundJids.length === 0) {
+      return jids.map(j => {
+        const { user } = stripUser(j);
+        const server   = j.includes('@lid') ? 'lid' : 's.whatsapp.net';
+        return `${user}@${server}`;
+      });
+    }
+    return foundJids;
+  }
+
+  // ─── Ensure sessions for LID JID members (no PN mapping available) ─────────
+  //
+  // Called from _sendGroupMessage for any LID group member where _lidToPn has
+  // no entry.  Queries usync by JID instead of phone number so the server can
+  // return the correct device list for LID-addressed participants.
+  //
+  async bulkEnsureSessionsByLidJids(lidJids, signalProto, allowPkmsg = true) {
+    if (!lidJids || lidJids.length === 0) return [];
+
+    const deviceJids = await this._usyncGetDevicesByJid(lidJids);
+
+    // In LID mode, ALL devices (including device=0) may have pre-keys and need
+    // Signal sessions.  We try to fetch bundles for every device; if the server
+    // returns 406 for device=0 (no pre-keys available) we simply skip that JID —
+    // but we still include it in the result so it appears in phash/SKDM list.
+    const readyJids = [];
+    const fetchJids = [];
+    const _sessKeys = Object.keys(signalProto.store._sessions || {});
+    process.stderr.write('[DBG] bulkEnsureLid storedSessionKeys=' + JSON.stringify(_sessKeys) + '\n');
+    for (const jid of deviceJids) {
+      const addrKey = this._jidToAddr(jid);
+      const hasSess = signalProto.store.hasSession(addrKey);
+      process.stderr.write('[DBG] hasSession jid=' + jid + ' addrKey=' + addrKey + ' result=' + hasSess + '\n');
+      if (hasSess) {
+        readyJids.push(jid);
+      } else {
+        fetchJids.push(jid);
+      }
+    }
+
+    process.stderr.write('[DBG] bulkEnsureLid deviceJids=' + JSON.stringify(deviceJids) + ' fetchJids=' + JSON.stringify(fetchJids) + '\n');
+
+    if (allowPkmsg && fetchJids.length > 0) {
+      const bundles = await this.fetchBundles(fetchJids);
+      process.stderr.write('[DBG] bulkEnsureLid bundles.size=' + bundles.size + '\n');
+      for (const [jid, bundle] of bundles) {
+        try {
+          await signalProto.buildSessionFromBundle(jid, bundle);
+          readyJids.push(typeof jid === 'string' ? jid : String(jid));
+        } catch (e) {
+          process.stderr.write('[DBG] bulkEnsureSessionsByLidJids bundle err jid=' + jid + ' ' + e.message + '\n');
+        }
+      }
+      // Any device we couldn't build a session for (e.g. 406, no pre-keys) still
+      // needs to appear in the result for phash correctness.
+      const sessionBuilt = new Set(readyJids);
+      for (const jid of fetchJids) {
+        if (!sessionBuilt.has(jid)) readyJids.push(jid);
+      }
+    } else {
+      // All devices already have sessions; add any that were not in fetchJids
+      for (const jid of deviceJids) {
+        if (!readyJids.includes(jid)) readyJids.push(jid);
+      }
+    }
+
+    const result = readyJids;
+
+    // Fallback: if still no secondaries found, return ALL device JIDs so that at
+    // least an SKDM attempt is made.
+    if (result.length === 0) {
+      return deviceJids;
+    }
+
+    return result;
+  }
+
   // ─── Invalidate cached device list (used on phash mismatch / 421 retry) ───
   clearCache(phones) {
     if (!phones || phones.length === 0) {
@@ -365,7 +608,23 @@ class DeviceManager {
     const toNodes = encryptedList.map(({ jid, type, ciphertext }) => {
       const encAttrs = { type, v: '2' };
       if (mediaSubtype) encAttrs.mediatype = mediaSubtype;
-      return new BinaryNode('to', { jid },
+      // Convert string JIDs to binary-encodable JID objects.
+      // "user_agent:device@server" → { user, agent, device, server }
+      let jidObj = jid;
+      if (typeof jid === 'string') {
+        const atIdx    = jid.indexOf('@');
+        const server   = atIdx >= 0 ? jid.slice(atIdx + 1) : 's.whatsapp.net';
+        const userPart = atIdx >= 0 ? jid.slice(0, atIdx) : jid;
+        const colonIdx = userPart.indexOf(':');
+        const base     = colonIdx >= 0 ? userPart.slice(0, colonIdx) : userPart;
+        const device   = colonIdx >= 0 ? parseInt(userPart.slice(colonIdx + 1), 10) : 0;
+        const underIdx = base.lastIndexOf('_');
+        const hasAgent = underIdx >= 0 && /^\d+$/.test(base.slice(underIdx + 1));
+        const user     = hasAgent ? base.slice(0, underIdx) : base;
+        const agent    = hasAgent ? parseInt(base.slice(underIdx + 1), 10) : 0;
+        jidObj = { user, agent: agent || 0, device: device || 0, server };
+      }
+      return new BinaryNode('to', { jid: jidObj },
         [new BinaryNode('enc', encAttrs, ciphertext)]
       );
     });

package/lib/messages/MessageSender.js

@@ -102,37 +102,22 @@ function _getCurve() {
   return _curve25519js;
 }
 
-// Build ADVSignedDeviceIdentity for our primary iOS device.
-// Returns Buffer of encoded proto WITH accountSignatureKey included.
-// Result is cached in store.advIdentity so we only build it once per registration.
+// Return ADVSignedDeviceIdentity if we have one from the server (received at login).
+// For phone-based (non-WA-Web) registrations the server never sends device-identity
+// in the <success> node, so store.advIdentity stays null.  In that case we return
+// null — the pkmsg stanza is sent WITHOUT a <device-identity> child, which is valid
+// for primary mobile devices and does NOT cause RETRY at the recipient.
+//
+// NOTE: Building a self-signed ADV from our own keys caused RETRY at recipient because
+// WhatsApp verifies the signature chain against the server-known account key.
 function _buildOrGetAdvIdentity(store) {
-  if (store.advIdentity && store.advIdentity.length > 0) return store.advIdentity;
-
-  try {
-    const curve   = _getCurve();
-    const pubRaw  = Buffer.from(store.identityKeyPair.public,  'base64');
-    const privRaw = Buffer.from(store.identityKeyPair.private, 'base64');
-    const pub32   = pubRaw.length === 33 ? pubRaw.slice(1) : pubRaw;
-    const priv32  = privRaw.length === 32 ? privRaw : privRaw.slice(0, 32);
-
-    const ts      = Math.floor(Date.now() / 1000);
-    const regId   = store.registrationId || 0;
-    const details = _encodeADVDetails(regId, ts, 0);
-
-    const acctMsg = Buffer.concat([WA_ADV_ACCOUNT_SIG_PREFIX, details, pub32]);
-    const acctSig = Buffer.from(curve.sign(priv32, acctMsg));
-
-    const devMsg  = Buffer.concat([WA_ADV_DEVICE_SIG_PREFIX, details, pub32, pub32]);
-    const devSig  = Buffer.from(curve.sign(priv32, devMsg));
-
-    const adv     = _encodeADVSignedIdentity(details, pub32, acctSig, devSig);
-    store.advIdentity = adv;
-    process.stderr.write('[DBG] ADV_BUILT from primary iOS keys (' + adv.length + 'b)\n');
-    return adv;
-  } catch (e) {
-    process.stderr.write('[DBG] ADV_BUILD_ERR: ' + e.message + '\n');
-    return null;
-  }
+  if (!store.advIdentity) return null;
+  const adv = Buffer.isBuffer(store.advIdentity)
+    ? store.advIdentity
+    : Buffer.from(store.advIdentity);
+  if (adv.length === 0) return null;
+  process.stderr.write('[DBG] ADV_PRESENT from server (' + adv.length + 'b)\n');
+  return adv;
 }
 
 function makeJid(input, server) {
@@ -621,6 +606,10 @@ class MessageSender {
     const ownPhone     = String(this._store.phoneNumber);
     const ownJid       = `${ownPhone}@s.whatsapp.net`;
     const mediaSubtype = options._mediaSubtype || null;
+    // LID-based own user number (e.g. "90079053799508"), used for phash in LID-mode groups.
+    // usync returns "@s.whatsapp.net" JIDs with the LID numeric ID as user when queried by
+    // LID JID, so the phash sender entry must use this number, NOT the phone number.
+    const myLidUser = this._client._myLid ? phoneFromJid(this._client._myLid) : null;
 
     // Auto-fetch group metadata if member cache is empty (first send to this group)
     let members = this._client._getGroupMembers(groupJid);
@@ -634,7 +623,12 @@ class MessageSender {
 
     // Determine addressing mode for this group (lid = modern groups, pn = legacy)
     const groupAddressingMode = this._client._groupAddressingMode.get(groupJid) || 'lid';
-    // For LID-mode groups, sender identity is own LID JID; otherwise own PN JID
+    // senderIdentity: For LID-mode groups the server tags our outbound message with
+    // participant = our LID JID (e.g. "90079053799508@lid") because addressing_mode='lid'.
+    // The recipient looks up the sender key by that participant JID, so we MUST store
+    // the SKDM and encrypt under the SAME identity.
+    // For legacy PN-mode groups the server uses the phone JID — fall back to ownJid.
+    // This mirrors Baileys: groupSenderIdentity = groupAddressingMode==='lid' && meLid ? meLid : meId
     const senderIdentity = (groupAddressingMode === 'lid' && this._client._myLid)
       ? this._client._myLid
       : ownJid;
@@ -642,38 +636,70 @@ class MessageSender {
     const rawSKDM   = this._signal.buildSKDM(groupJid, senderIdentity);
     const skdmMsg   = encodeSenderKeyDistributionMessage(groupJid, rawSKDM);
 
-    const memberPhones = [...new Set(
-      members.map(jid => {
-        const isLid = jid.endsWith('@lid');
-        const raw   = phoneFromJid(jid);
-        if (isLid) {
-          const pn = this._client._lidToPn && this._client._lidToPn.get(raw);
-          if (!pn) {
-            process.stderr.write('[DBG] GROUP_SEND skip LID member with no PN mapping: ' + jid + '\n');
-            return null;
-          }
-          return pn;
-        }
-        return raw;
-      }).filter(p => p !== null && p !== ownPhone)
-    )];
+    // Separate members into two buckets:
+    //   1. knownPhones  — members whose phone number is known (from LID→PN map or direct PN JID)
+    //   2. unknownLids  — LID JIDs with no PN mapping yet (common on first send to a group)
+    //
+    // FIX: Previously, bucket-2 members were silently skipped (return null), which meant
+    // SKDM (Sender Key Distribution Message) was never sent to them.  Recipients would
+    // receive the skmsg ciphertext but could not decrypt it — messages appeared "waiting".
+    //
+    // Cobalt solves this by querying usync directly with JID= nodes instead of phone numbers,
+    // allowing the server to resolve devices for LID-addressed participants.  We mirror that
+    // approach via DeviceManager.bulkEnsureSessionsByLidJids().
+    const knownPhones  = [];
+    const unknownLids  = [];
+
+    for (const jid of members) {
+      const isLid = jid.endsWith('@lid');
+      const raw   = phoneFromJid(jid);
+
+      if (isLid) {
+        // Skip own LID identity
+        if (raw === myLidUser) continue;
+        // KEY FIX: For LID-mode groups the server only responds to LID-based usync queries
+        // (i.e. <user jid="...@lid"/>), NOT to phone-number-based queries
+        // (<contact>+phone</contact>).  Always route ALL LID members through
+        // bulkEnsureSessionsByLidJids() regardless of whether we know their PN.
+        unknownLids.push(jid);
+      } else if (raw !== ownPhone) {
+        // Legacy PN-mode group — use conventional phone-number usync
+        knownPhones.push(raw);
+      }
+    }
+
+    const uniquePhones = [...new Set(knownPhones)];
+    const uniqueLids   = [...new Set(unknownLids)];
+
+    process.stderr.write('[DBG] GROUP_SEND ' + groupJid + ' knownPhones=' + uniquePhones.length + ' unknownLids=' + uniqueLids.length + '\n');
 
-    const [memberDevices, ownDevices] = await Promise.all([
-      memberPhones.length > 0
-        ? this._devMgr.bulkEnsureSessions(memberPhones, this._signal)
+    const [memberDevicesPN, memberDevicesLid, ownDevices] = await Promise.all([
+      uniquePhones.length > 0
+        ? this._devMgr.bulkEnsureSessions(uniquePhones, this._signal)
+        : Promise.resolve([]),
+      uniqueLids.length > 0
+        ? this._devMgr.bulkEnsureSessionsByLidJids(uniqueLids, this._signal)
         : Promise.resolve([]),
       this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal)
     ]);
 
-    const allTargets = [...memberDevices, ...ownDevices];
+    const allTargets = [...memberDevicesPN, ...memberDevicesLid, ...ownDevices];
+
+    process.stderr.write('[DBG] GROUP senderIdentity=' + senderIdentity + ' groupAddressingMode=' + groupAddressingMode + ' myLid=' + this._client._myLid + '\n');
 
-    const phashTargets = allTargets.includes(ownJid)
-      ? allTargets
-      : [ownJid, ...allTargets];
+    // phash: Baileys uses device JIDs of all RECIPIENTS (own secondary devices + others).
+    // We don't have own secondary devices, so phash = memberDevices only.
+    // We're currently sending phash=null and let server compute it (see below).
+    const phashOwnJid = ownJid;
+    // memberTargets = only other participants' devices (PN + LID), no own secondary devices
+    const memberTargets = [...memberDevicesPN, ...memberDevicesLid];
+    const phashTargets = [phashOwnJid, ...memberTargets.filter(j => j !== phashOwnJid)];
+    process.stderr.write('[DBG] phashOwnJid=' + phashOwnJid + ' memberTargets=' + JSON.stringify(memberTargets) + ' ownDevices=' + JSON.stringify(ownDevices) + '\n');
 
     const skStore        = this._signal.senderKeyStore;
     const existingSkdmMap = skStore.getSKDMMap(groupJid);
     const skdmRecipients  = allTargets.filter(jid => !existingSkdmMap[jid]);
+    process.stderr.write('[DBG] allTargets=' + JSON.stringify(allTargets) + ' skdmRecipients=' + JSON.stringify(skdmRecipients) + ' existingSkdmKeys=' + JSON.stringify(Object.keys(existingSkdmMap)) + '\n');
 
     let skdmEncrypted = [];
     if (skdmRecipients.length > 0) {
@@ -682,10 +708,13 @@ class MessageSender {
     }
 
     const skmsgCiphertext = this._signal.senderKeyEncrypt(groupJid, senderIdentity, plaintext);
-    const phash = phashTargets.length > 0 ? computePhash(phashTargets) : null;
+    const phashComputed = phashTargets.length > 0 ? computePhash(phashTargets) : null;
+    const phash = null; // TEST: force no phash to see server response
+    process.stderr.write('[DBG] phashTargets=' + JSON.stringify(phashTargets) + ' computed phash=' + phashComputed + ' (sending: ' + phash + ')\n');
 
     const skdmHasPkmsg = skdmEncrypted.some(e => e.type === 'pkmsg');
     const advBytes     = skdmHasPkmsg ? _buildOrGetAdvIdentity(this._client._store) : null;
+    process.stderr.write('[DBG] skdmHasPkmsg=' + skdmHasPkmsg + ' advBytes=' + (advBytes ? advBytes.length + 'b' : 'null') + '\n');
 
     const msgContent = [];
     if (advBytes) {

package/lib/proto/MessageProto.js

@@ -380,12 +380,14 @@ function decodeMessageContainer(buf) {
       if (dsm[2]) return decodeMessageContainer(dsm[2]);
     }
 
-    // Field 35: senderKeyDistributionMessage — used to set up sender keys.
+    // Field 2: senderKeyDistributionMessage (WAProto: Message.senderKeyDistributionMessage = 2)
     // In WhatsApp Multi-Device, SKDM is bundled WITH the first real message in a new
     // session (even for 1-on-1 DMs). We extract it and continue decoding the real message.
+    // Also check field 15 (fastRatchetKeySenderKeyDistributionMessage) as a fallback.
     let skdmInfo = null;
-    if (f[35]) {
-      const skdm = _decodeFields(f[35]);
+    const skdmRaw = f[2] || f[15];
+    if (skdmRaw) {
+      const skdm = _decodeFields(skdmRaw);
       // field 1 = groupId (string), field 2 = axolotlSenderKeyDistributionMessage (bytes)
       skdmInfo = {
         groupId: _str(skdm[1]),
@@ -403,10 +405,10 @@ function decodeMessageContainer(buf) {
       if (text) msgResult = { type: 'text', text };
     }
 
-    // Field 2: extendedTextMessage — field 1 = text
-    if (!msgResult && f[2] && Buffer.isBuffer(f[2])) {
+    // Field 6: extendedTextMessage (WAProto: Message.extendedTextMessage = 6) — field 1 = text
+    if (!msgResult && f[6] && Buffer.isBuffer(f[6])) {
       try {
-        const ext = _decodeFields(f[2]);
+        const ext = _decodeFields(f[6]);
         const text = _str(ext[1]);
         if (text) msgResult = { type: 'text', text };
       } catch (_) {}
@@ -570,11 +572,13 @@ function decodeMessageContainer(buf) {
 }
 
 function encodeSenderKeyDistributionMessage(groupId, axolotlBytes) {
+  // WAProto: Message.senderKeyDistributionMessage = field 2
+  // Inner: SenderKeyDistributionMessage { groupId=1 (string), axolotlSKDM=2 (bytes) }
   const inner = Buffer.concat([
     field(1, WIRE_LEN, str(groupId)),
     field(2, WIRE_LEN, bytes(axolotlBytes))
   ]);
-  return field(35, WIRE_LEN, inner);
+  return field(2, WIRE_LEN, inner);
 }
 
 module.exports = {

package/lib/signal/SenderKey.js

@@ -178,6 +178,7 @@ class SenderKeyStore {
   }
 
   markSKDMSent(groupId, jids) {
+    process.stderr.write('[DBG] markSKDMSent groupId=' + groupId + ' jids=' + JSON.stringify(jids) + '\n' + new Error().stack.split('\n').slice(1,4).join('\n') + '\n');
     const map = this.getSKDMMap(groupId);
     for (const jid of jids) map[jid] = true;
     this.setSKDMMap(groupId, map);

package/lib/signal/SignalProtocol.js

@@ -170,6 +170,8 @@ class SignalProtocol {
         publicKey: bundle.preKey.publicKey
       } : undefined
     });
+    const hasSess = this.store.hasSession(addr.toString ? addr.toString() : (addr.name + '.' + addr.deviceId));
+    process.stderr.write('[DBG] SESSION_BUILT jid=' + jid + ' addr=' + addr.name + '.' + addr.deviceId + ' hasSess=' + hasSess + '\n');
   }
 
   async buildSessionsFromBundles(bundleMap) {
@@ -220,11 +222,18 @@ class SignalProtocol {
   // Returns [{jid, type, ciphertext}]
   async bulkEncryptForDevices(jids, plaintext) {
     const settled = await Promise.allSettled(
-      jids.map(jid => this.encrypt(jid, plaintext).then(enc => ({ jid, type: enc.type, ciphertext: enc.ciphertext })))
+      jids.map(jid => this.encrypt(jid, plaintext).then(enc => {
+        process.stderr.write('[DBG] SKDM_ENC jid=' + jid + ' type=' + enc.type + ' len=' + (enc.ciphertext ? enc.ciphertext.length : 0) + '\n');
+        return { jid, type: enc.type, ciphertext: enc.ciphertext };
+      }))
     );
-    return settled
+    const results = settled
       .filter(r => r.status === 'fulfilled')
       .map(r => r.value);
+    settled.filter(r => r.status === 'rejected').forEach((r, i) => {
+      process.stderr.write('[DBG] SKDM_ENC_ERR jid=' + jids[i] + ' err=' + r.reason + '\n');
+    });
+    return results;
   }
 
   // ─── SenderKey group encrypt / decrypt ────────────────────────────────────
@@ -293,6 +302,11 @@ function jidToAddress(jid) {
       deviceId = parseInt(user.slice(colonIdx + 1), 10) || 0;
       user     = user.slice(0, colonIdx);
     }
+    // Strip agent suffix from user (e.g. "112713111982325_1" → "112713111982325")
+    const underIdx = user.lastIndexOf('_');
+    if (underIdx >= 0 && /^\d+$/.test(user.slice(underIdx + 1))) {
+      user = user.slice(0, underIdx);
+    }
   } else if (jid && jid.user) {
     user     = jid.user;
     deviceId = jid.device || 0;

package/package.json

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