whalibmob 5.5.64 → 5.5.66

package/lib/BinaryNode.js

@@ -127,9 +127,25 @@ function _writeBytes(buf, parts) {
   parts.push(buf);
 }
 
+// AD_JID agent byte ↔ domain. 0 = phone JIDs, 1 = LIDs.
+const _AGENT_SERVER = { 0: 's.whatsapp.net', 1: 'lid' };
+function _serverForAgent(agent) {
+  return _AGENT_SERVER[agent] || 's.whatsapp.net';
+}
+function _agentForServer(server) {
+  return server === 'lid' ? 1 : 0;
+}
+
 function _writeJid(jid, parts) {
-  if (jid.agent || jid.device) {
-    parts.push(Buffer.from([TAG.AD_JID, jid.agent || 0, jid.device || 0]));
+  // Derive the agent from the domain only when this JID is going out as AD_JID
+  // anyway (explicit agent, or a device suffix). A plain LID keeps its
+  // JID_PAIR + 'lid' server-token encoding, which is what the server expects
+  // and what the rest of the codebase already produces.
+  const agent = (jid.agent !== undefined && jid.agent !== null)
+    ? jid.agent
+    : (jid.device ? _agentForServer(jid.server) : 0);
+  if (agent || jid.device) {
+    parts.push(Buffer.from([TAG.AD_JID, agent || 0, jid.device || 0]));
     _writeString(jid.user, parts);
   } else {
     parts.push(Buffer.from([TAG.JID_PAIR]));
@@ -289,7 +305,15 @@ class NodeDecoder {
     const device = this._readByte();
     const userToken = this._readByte();
     const user = this._readString(userToken);
-    return { user, agent, device, server: 's.whatsapp.net', toString() { return `${user}@s.whatsapp.net`; } };
+    // The agent byte selects the domain — it is not decoration. Hardcoding
+    // s.whatsapp.net turned every LID participant (agent 1) into a phone JID
+    // that does not exist, so device queries for it came back empty, no Signal
+    // session was ever built, and group sends were rejected with ack 479.
+    const server = _serverForAgent(agent);
+    return {
+      user, agent, device, server,
+      toString() { return `${user}@${server}`; }
+    };
   }
 }
 

package/lib/Client.js

@@ -148,8 +148,11 @@ class WhalibmobClient extends EventEmitter {
     this._pnToLid          = new Map();   // phone number → LID user
     this._myLid            = null;        // own LID JID received from <success> node
     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
+    this._retryPending     = new Map();   // msgId → {node, count, pkId}
+    this._retryPreKeyIdx   = 0;           // rotating index, fallback when every prekey is reserved
+    // keyIds handed out by unresolved retries — never advertise one twice, or
+    // the second sender's pkmsg arrives after the key was consumed and deleted.
+    this._retryAdvertisedPreKeys = new Set();
     this._appStateVersions = {};          // collectionName → version (int)
     this._sentMsgCache     = new Map();   // msgId → {plaintext, toJid, msgId, mediaType, options, recipientPhone}
     this._tcTokenStore            = null; // TcTokenStore — loaded in init()
@@ -686,6 +689,7 @@ class WhalibmobClient extends EventEmitter {
 
     this._signal.decrypt(sigJid, encType, cipherBuf)
       .then(async plaintext => {
+        this._resolveRetry(id);
         const decoded = this._decodeMsg(plaintext);
         _whaDbg('[DBG] DM_DECODED id=' + id + ' type=' + decoded.type + ' ptLen=' + (plaintext ? plaintext.length : 0) + ' hasSKDM=' + !!(decoded.skdm || decoded.type === 'senderKeyDistribution'));
 
@@ -756,6 +760,7 @@ class WhalibmobClient extends EventEmitter {
 
     this._signal.senderKeyDecrypt(from, participant, cipherBuf)
       .then(plaintext => {
+        this._resolveRetry(id);
         const decoded = this._decodeMsg(plaintext);
         if (decoded.type === 'senderKeyDistribution') return;
         if (decoded.type === 'protocol') {
@@ -959,6 +964,17 @@ class WhalibmobClient extends EventEmitter {
   //   - <registration> 4-byte reg-id
   //   - <keys> block (from retry #1): type + identity + key + skey + device-identity
 
+  // A message we asked to be re-sent finally decrypted (or we gave up on it).
+  // Release its reserved prekey so the pool does not drain over a long session.
+  _resolveRetry(msgId) {
+    const pending = this._retryPending.get(msgId);
+    if (!pending) return;
+    if (pending.pkId !== null && pending.pkId !== undefined) {
+      this._retryAdvertisedPreKeys.delete(pending.pkId);
+    }
+    this._retryPending.delete(msgId);
+  }
+
   _sendRetryRequest(msgId, origNode) {
     const existing = this._retryPending.get(msgId);
     const count    = existing ? existing.count + 1 : 1;
@@ -966,13 +982,25 @@ class WhalibmobClient extends EventEmitter {
 
     if (!this._socket || !this._connected) return;
 
-    // Assign a stable, unique prekey index per msgId on first retry
-    let pkIdx = existing ? existing.pkIdx : -1;
-    if (pkIdx < 0 && this._signal) {
+    // Pick a prekey that is not already advertised by another unresolved retry.
+    // A prekey is deleted the moment a pkmsg using it is decrypted, so handing
+    // the same one to two senders means the second arrives after the key is
+    // gone and dies with "Invalid PreKey ID". Indexing modulo the key count
+    // could not prevent that: the list shrinks as keys are consumed, so the
+    // rotating index wraps back onto ids that are still in flight.
+    let pkId = existing ? existing.pkId : null;
+    if (pkId === null && this._signal) {
       const allKeys = this._signal.getPreKeysForUpload(800);
-      pkIdx = this._retryPreKeyIdx++ % Math.max(1, allKeys.length);
+      const free = allKeys.find(k => !this._retryAdvertisedPreKeys.has(k.keyId));
+      // If every key is already spoken for, fall back to rotating rather than
+      // sending no bundle at all — a stale id beats no retry.
+      const chosen = free || allKeys[this._retryPreKeyIdx++ % Math.max(1, allKeys.length)];
+      if (chosen) {
+        pkId = chosen.keyId;
+        this._retryAdvertisedPreKeys.add(pkId);
+      }
     }
-    this._retryPending.set(msgId, { node: origNode, count, pkIdx });
+    this._retryPending.set(msgId, { node: origNode, count, pkId });
 
     // Use original message timestamp (not current time)
     const origAttrs = (origNode && origNode.attrs) || {};
@@ -991,7 +1019,7 @@ class WhalibmobClient extends EventEmitter {
         const spk        = this._signal.getSignedPreKeyForUpload();
         const identKey   = this._signal.getIdentityKey();
         const allPreKeys = this._signal.getPreKeysForUpload(800);
-        const pk         = allPreKeys[pkIdx] || allPreKeys[0];
+        const pk         = allPreKeys.find(k => k.keyId === pkId) || allPreKeys[0];
 
         if (spk && identKey && pk) {
           const keysChildren = [

package/lib/messages/MessageSender.js

@@ -839,10 +839,22 @@ 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
-    const senderIdentity = (groupAddressingMode === 'lid' && this._client._myLid)
-      ? this._client._myLid
-      : ownJid;
+    // A stanza addressed with addressing_mode='lid' must carry participants in
+    // LID space only. Mixing @s.whatsapp.net targets into it is exactly what
+    // DeviceManager warns about, and the server answers it with ack 479.
+    const useLid = groupAddressingMode === 'lid';
+    if (useLid && !this._client._myLid) {
+      throw new Error(
+        'Cannot send to ' + groupJid + ': group is LID-addressed but our own LID ' +
+        'is unknown (the server did not supply lid= on <success>). ' +
+        'Reconnect so the LID is re-issued.'
+      );
+    }
+    const myLidUser = useLid ? phoneFromJid(this._client._myLid) : null;
+    // For LID-mode groups, sender identity is own LID JID; otherwise own PN JID.
+    // Normalised to the bare user so it matches the participant targets below.
+    const selfJid = useLid ? `${myLidUser}@lid` : ownJid;
+    const senderIdentity = selfJid;
 
     const rawSKDM   = await this._signal.buildSKDM(groupJid, senderIdentity);
     const skdmMsg   = encodeSenderKeyDistributionMessage(groupJid, rawSKDM);
@@ -850,16 +862,31 @@ class MessageSender {
     // Resolve member phones for session/device queries.
     // For LID members without a PN mapping, keep the raw LID user part so
     // bulkEnsureSessionsForLid can still acquire sessions for them.
+    // "40778226909:2@s.whatsapp.net" → "<ourLid>:2@lid" — keep the device
+    // suffix, swap identity and domain.
+    const ownJidToLid = (jid) => {
+      const base   = String(jid).replace(/@(?:s\.whatsapp\.net|lid)$/, '');
+      const colon  = base.indexOf(':');
+      return myLidUser + (colon >= 0 ? base.slice(colon) : '') + '@lid';
+    };
+
     const lidMembersWithoutPn = [];
     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) return pn;
-          // No PN mapping yet — track for LID-direct session ensure
-          lidMembersWithoutPn.push(jid);
+          // In a LID-addressed group, resolve LID members through the LID path
+          // even when we know their phone number — swapping in the PN would put
+          // an @s.whatsapp.net target into a @lid stanza.
+          if (!useLid) {
+            const pn = this._client._lidToPn && this._client._lidToPn.get(raw);
+            if (pn) return pn;
+          }
+          // Our own LID is a member too — ensureOwnDeviceSessions already
+          // covers those devices, so listing it here would encrypt the SKDM
+          // for ourselves twice and emit duplicate <to> entries.
+          if (raw !== myLidUser) lidMembersWithoutPn.push(jid);
           return null;
         }
         return raw;
@@ -879,11 +906,17 @@ class MessageSender {
       this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal)
     ]);
 
-    const allTargets = [...memberDevices, ...lidDevices, ...ownDevices];
+    // Own devices come back as @s.whatsapp.net — re-express them in LID space
+    // so every target in a LID stanza shares one address family.
+    const ownTargets = useLid ? ownDevices.map(ownJidToLid) : ownDevices;
+
+    // Dedupe: a device reached through more than one path must still appear
+    // exactly once in <participants>.
+    const allTargets = [...new Set([...memberDevices, ...lidDevices, ...ownTargets])];
 
-    const phashTargets = allTargets.includes(ownJid)
+    const phashTargets = allTargets.includes(selfJid)
       ? allTargets
-      : [ownJid, ...allTargets];
+      : [selfJid, ...allTargets];
 
     const skStore        = this._signal.senderKeyStore;
     const existingSkdmMap = skStore.getSKDMMap(groupJid);

package/package.json

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