whalibmob 5.5.64 → 5.5.65

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/package.json

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