whalibmob 5.1.19 → 5.1.21

package/README.md

@@ -6,6 +6,12 @@
 > [!CAUTION]
 > Use a dedicated phone number with this library. Connecting with a number that is already active on a real device will cause WhatsApp to log that device out.
 
+This product is free for everyone but if you want to support more whalibmob or others you can support me with some USD donations through Crypto at This product is free for everyone but if you want us to support more whalibmob or others you can support me with some USD donations through Crypto at    0x8AD64F47a715eC24DeF193FBb9aC64d4E857f0f3
+
+
+
+
+
 > [!IMPORTANT]
 > This project is not affiliated, associated, authorized, endorsed by, or in any way officially connected with WhatsApp or any of its subsidiaries or affiliates. "WhatsApp" and related names are registered trademarks of their respective owners. Use at your own discretion.
 

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.21",
   "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