whalibmob 5.1.19 → 5.1.20

package/lib/Client.js

@@ -103,27 +103,6 @@ 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 {
@@ -149,7 +128,6 @@ 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
@@ -306,10 +284,7 @@ class WhalibmobClient extends EventEmitter {
       }
     }
     if (attrs.platform) this._platform = attrs.platform;
-    if (attrs.lid) {
-      this._myLid      = _adJidToLid(attrs.lid);
-      this._myLidAgent = (typeof attrs.lid === 'object' && attrs.lid.agent) ? attrs.lid.agent : 0;
-    }
+    if (attrs.lid)      this._myLid    = String(attrs.lid);
 
     const devIdNode = findChild(node, 'device-identity');
     if (devIdNode) {
@@ -822,9 +797,6 @@ 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);
@@ -1212,17 +1184,12 @@ class WhalibmobClient extends EventEmitter {
     const participants = children
       .filter(n => n && n.description === 'participant' && n.attrs && n.attrs.jid)
       .map(n => {
-        // AD JID objects (LID participants) have an `agent` property → convert to @lid form
-        const pJid  = _adJidToLid(n.attrs.jid);
+        const pJid  = String(n.attrs.jid);
         const pRole = n.attrs.type || 'member';
-        // 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;
+        const pPhone = n.attrs.phone_number ? String(n.attrs.phone_number) : null;
+        const pLid   = n.attrs.lid          ? String(n.attrs.lid)          : null;
         // Populate LID↔PN maps from participant attributes
-        // Case A: participant JID is a LID (ends with @lid), phone_number is their PN
+        // Case A: participant JID is a LID, phone_number is their PN
         if (pJid.endsWith('@lid')) {
           const lidUser = pJid.split('@')[0].split(':')[0];
           if (pPhone) {
@@ -1330,18 +1297,12 @@ class WhalibmobClient extends EventEmitter {
     const response = await this._sendIq(node);
     if (!response) return [];
 
-    // 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);
+    // 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);
     return groups;
   }
 

package/lib/DeviceManager.js

@@ -5,24 +5,17 @@ const { BinaryNode } = require('./BinaryNode');
 // ─── JID helpers ─────────────────────────────────────────────────────────────
 
 function stripUser(jid) {
-  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 };
+  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 };
 }
 
-function makeDeviceJid(user, device, server, agent) {
+function makeDeviceJid(user, device, server) {
   server = server || 's.whatsapp.net';
-  agent  = agent  || 0;
-  const agentStr = agent !== 0 ? `_${agent}` : '';
-  if (!device || device === 0) return `${user}${agentStr}@${server}`;
-  return `${user}${agentStr}:${device}@${server}`;
+  if (!device || device === 0) return `${user}@${server}`;
+  return `${user}:${device}@${server}`;
 }
 
 function phoneFromJid(jid) {
@@ -130,22 +123,7 @@ class DeviceManager {
   async fetchBundles(jids) {
     if (!jids || jids.length === 0) return new Map();
 
-    // 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 userNodes = jids.map(jid => { const lidMatch = jid.match(/(\d{15,})@s\.whatsapp\.net/); return new BinaryNode('user', { jid }, null); });
     const iqId   = this._client._genMsgId();
     const iqNode = new BinaryNode('iq',
       { id: iqId, xmlns: 'encrypt', type: 'get', to: 's.whatsapp.net' },
@@ -160,28 +138,10 @@ class DeviceManager {
     const children = listNode ? listNode.content : (response.content || []);
     for (const userNode of (Array.isArray(children) ? children : [])) {
       if (!userNode || userNode.description !== 'user') 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 jid = userNode.attrs && userNode.attrs.jid;
+      if (!jid) continue;
       const bundle = parseBundleFromUserNode(userNode);
-      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');
-      }
+      if (bundle) bundles.set(jid, bundle);
     }
     return bundles;
   }
@@ -239,17 +199,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', { jid: { user: String(p), server: 's.whatsapp.net' } }, null)
+      new BinaryNode('user', {},
+        [new BinaryNode('contact', {}, Buffer.from('+' + p))]
+      )
+    );
+    const deviceChildren = phones.map(p =>
+      new BinaryNode('device', { jid: makeDeviceJid(p, 0) }, null)
     );
 
     const iqNode = new BinaryNode('iq',
@@ -258,77 +218,34 @@ class DeviceManager {
         { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
         [
           new BinaryNode('query', {},
-            [new BinaryNode('devices', { version: '2' }, null)]
+            [new BinaryNode('devices', { version: '2' }, deviceChildren)]
           ),
-          new BinaryNode('list',      {}, listChildren),
-          new BinaryNode('side_list', {}, null)
+          new BinaryNode('list', {}, listChildren)
         ]
       )]
     );
 
     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);
-  }
 
-  // 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
+    // Walk response and populate cache
+    const found = new Set();
     function walk(node) {
       if (!node) return;
-      if (node.description === 'user') { walkUser(node); return; }
-      if (Array.isArray(node.content)) node.content.forEach(walk);
+      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));
     }
-    walk(response);
+    if (response) walk.call(this, response);
 
-    // 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]));
+    // 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]));
       }
     }
   }
@@ -433,166 +350,6 @@ 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) {
@@ -608,23 +365,7 @@ class DeviceManager {
     const toNodes = encryptedList.map(({ jid, type, ciphertext }) => {
       const encAttrs = { type, v: '2' };
       if (mediaSubtype) encAttrs.mediatype = mediaSubtype;
-      // 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 },
+      return new BinaryNode('to', { jid },
         [new BinaryNode('enc', encAttrs, ciphertext)]
       );
     });

package/lib/messages/MessageSender.js

@@ -102,22 +102,37 @@ function _getCurve() {
   return _curve25519js;
 }
 
-// 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.
+// 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.
 function _buildOrGetAdvIdentity(store) {
-  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;
+  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;
+  }
 }
 
 function makeJid(input, server) {
@@ -606,10 +621,6 @@ 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);
@@ -623,12 +634,7 @@ class MessageSender {
 
     // Determine addressing mode for this group (lid = modern groups, pn = legacy)
     const groupAddressingMode = this._client._groupAddressingMode.get(groupJid) || 'lid';
-    // 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
+    // For LID-mode groups, sender identity is own LID JID; otherwise own PN JID
     const senderIdentity = (groupAddressingMode === 'lid' && this._client._myLid)
       ? this._client._myLid
       : ownJid;
@@ -636,70 +642,38 @@ class MessageSender {
     const rawSKDM   = this._signal.buildSKDM(groupJid, senderIdentity);
     const skdmMsg   = encodeSenderKeyDistributionMessage(groupJid, rawSKDM);
 
-    // 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 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)
+    )];
 
-    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)
+    const [memberDevices, ownDevices] = await Promise.all([
+      memberPhones.length > 0
+        ? this._devMgr.bulkEnsureSessions(memberPhones, this._signal)
         : Promise.resolve([]),
       this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal)
     ]);
 
-    const allTargets = [...memberDevicesPN, ...memberDevicesLid, ...ownDevices];
-
-    process.stderr.write('[DBG] GROUP senderIdentity=' + senderIdentity + ' groupAddressingMode=' + groupAddressingMode + ' myLid=' + this._client._myLid + '\n');
+    const allTargets = [...memberDevices, ...ownDevices];
 
-    // 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 phashTargets = allTargets.includes(ownJid)
+      ? allTargets
+      : [ownJid, ...allTargets];
 
     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) {
@@ -708,13 +682,10 @@ class MessageSender {
     }
 
     const skmsgCiphertext = this._signal.senderKeyEncrypt(groupJid, senderIdentity, plaintext);
-    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 phash = phashTargets.length > 0 ? computePhash(phashTargets) : null;
 
     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,14 +380,12 @@ function decodeMessageContainer(buf) {
       if (dsm[2]) return decodeMessageContainer(dsm[2]);
     }
 
-    // Field 2: senderKeyDistributionMessage (WAProto: Message.senderKeyDistributionMessage = 2)
+    // Field 35: senderKeyDistributionMessage — used to set up sender keys.
     // 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;
-    const skdmRaw = f[2] || f[15];
-    if (skdmRaw) {
-      const skdm = _decodeFields(skdmRaw);
+    if (f[35]) {
+      const skdm = _decodeFields(f[35]);
       // field 1 = groupId (string), field 2 = axolotlSenderKeyDistributionMessage (bytes)
       skdmInfo = {
         groupId: _str(skdm[1]),
@@ -405,10 +403,10 @@ function decodeMessageContainer(buf) {
       if (text) msgResult = { type: 'text', text };
     }
 
-    // Field 6: extendedTextMessage (WAProto: Message.extendedTextMessage = 6) — field 1 = text
-    if (!msgResult && f[6] && Buffer.isBuffer(f[6])) {
+    // Field 2: extendedTextMessage — field 1 = text
+    if (!msgResult && f[2] && Buffer.isBuffer(f[2])) {
       try {
-        const ext = _decodeFields(f[6]);
+        const ext = _decodeFields(f[2]);
         const text = _str(ext[1]);
         if (text) msgResult = { type: 'text', text };
       } catch (_) {}
@@ -572,13 +570,11 @@ 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(2, WIRE_LEN, inner);
+  return field(35, WIRE_LEN, inner);
 }
 
 module.exports = {

package/lib/signal/SenderKey.js

@@ -178,7 +178,6 @@ 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,8 +170,6 @@ 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) {
@@ -222,18 +220,11 @@ class SignalProtocol {
   // Returns [{jid, type, ciphertext}]
   async bulkEncryptForDevices(jids, plaintext) {
     const settled = await Promise.allSettled(
-      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 };
-      }))
+      jids.map(jid => this.encrypt(jid, plaintext).then(enc => ({ jid, type: enc.type, ciphertext: enc.ciphertext })))
     );
-    const results = settled
+    return 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 ────────────────────────────────────
@@ -302,11 +293,6 @@ 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.19",
+  "version": "5.1.20",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto20",
   "main": "index.js",

package/.env.example

@@ -1,44 +0,0 @@
-# ─────────────────────────────────────────────────────────────────────────────
-# whalibmob — iPhone Device Emulation Configuration
-# Copy this file to .env in your project root and set the values you need.
-# All variables are optional; the library picks a random iPhone by default.
-# ─────────────────────────────────────────────────────────────────────────────
-
-# Named iPhone profile to emulate.
-# If not set, the library picks a random iPhone from the list below.
-#
-# Available profiles:
-#   iphone16promax, iphone16pro, iphone16plus, iphone16,
-#   iphone15promax, iphone15pro, iphone15plus, iphone15,
-#   iphone14promax, iphone14pro, iphone14plus, iphone14,
-#   iphone13pro, iphone13, iphone12pro, iphone12,
-#   iphone11pro, iphone11, iphonese3, iphonexs
-#
-# WA_DEVICE=iphone16pro
-
-# ── Custom iPhone overrides ──────────────────────────────────────────────────
-# Use these to emulate a specific iPhone model not in the list above.
-# All values are sent as-is in the WhatsApp registration and connection.
-
-# WA_DEVICE_MODEL=iPhone 16 Pro Max
-# WA_DEVICE_OS_VERSION=18.3.2
-# WA_DEVICE_BUILD=22D82
-# WA_DEVICE_MODEL_ID=iPhone17,2
-
-# ── Version & token overrides ────────────────────────────────────────────────
-
-# Pin the WhatsApp version string instead of fetching the latest from the
-# App Store (iTunes lookup).  Format: 2.x.x.x (four-part).
-# WA_VERSION=2.26.10.74
-
-# Override the built-in iOS static secret used in the token MD5 formula:
-#   token = MD5( WA_STATIC_TOKEN + MD5hex(version) + nationalNumber )
-# Only needed if WhatsApp rotates the built-in secret.
-# WA_STATIC_TOKEN=0a1mLfGUIBVrMKF1RdvLI5lkRBvof6vn0fD2QRSM
-
-# ── Proxy / Tor ──────────────────────────────────────────────────────────────
-
-# Route registration HTTP traffic through a SOCKS5 proxy or Tor.
-# Residential proxies recommended to avoid WhatsApp security blocks.
-# TOR_PROXY=socks5://127.0.0.1:9050
-# SOCKS_PROXY=socks5://user:pass@proxy.example.com:1080