whalibmob 5.5.70 → 5.5.72

package/lib/Client.js

@@ -11,6 +11,11 @@ const { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, assert
 const { getDeviceConfig } = require('./DeviceConfig');
 const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts } = require('./Store');
 const { BinaryNode }      = require('./BinaryNode');
+
+// How many times a message may be re-sent in answer to retry receipts before
+// the client stops. Each resend can itself draw retries, so this is what keeps
+// an undecryptable message from turning into a flood.
+const MAX_RETRY_RESENDS = 2;
 const { NodeCache }       = require('@cacheable/node-cache');
 
 // Group metadata cache lifetime — matches DeviceManager's device cache.
@@ -877,9 +882,33 @@ class WhalibmobClient extends EventEmitter {
       return;
     }
 
-    const fromStr       = attrs.from ? String(attrs.from) : '';
-    // Extract bare phone number: "40756469325@s.whatsapp.net" → "40756469325"
-    const recipientPhone = fromStr.split('@')[0].split('.')[0];
+    // Consume the entry before doing anything else. Every device that failed to
+    // decrypt sends its own retry receipt for the same message, and a group
+    // resend already re-addresses all of them — without this, each receipt
+    // started its own resend.
+    this._sentMsgCache.delete(msgId);
+
+    // Bound the chain. A resend that still cannot be decrypted draws fresh
+    // retry receipts of its own, so an unbounded handler answers each one with
+    // another send and floods the chat. Give up after a few rounds and leave
+    // the message undelivered rather than keep spamming.
+    const depth = (cached.retryDepth || 0) + 1;
+    if (depth > MAX_RETRY_RESENDS) {
+      _whaDbg('[DBG] RETRY_RECV msgId=' + msgId + ' — giving up after ' +
+        cached.retryDepth + ' resends\n');
+      return;
+    }
+
+    const fromStr = attrs.from ? String(attrs.from) : '';
+    const isGroup = fromStr.endsWith('@g.us');
+
+    // On a group retry `from` is the group and `participant` is the device that
+    // failed to decrypt. Keying off `from` there would have targeted the group
+    // id as if it were a contact and cleared nothing.
+    const targetJid = isGroup && attrs.participant
+      ? String(attrs.participant)
+      : fromStr;
+    const recipientPhone = targetJid.split('@')[0].split(':')[0].split('.')[0];
 
     _whaDbg('[DBG] RETRY_RECV msgId=' + msgId + ' from=' + fromStr + ' — clearing session + resending\n');
 
@@ -900,9 +929,31 @@ class WhalibmobClient extends EventEmitter {
       this._devMgr.clearCache([recipientPhone]);
     }
 
-    // Re-send the message — will create fresh pre-key (pkmsg) sessions
+    // Re-send the message — will create fresh pre-key (pkmsg) sessions.
+    // A group resend must go back through the group path: it needs a fresh
+    // SenderKey distribution, which only _sendGroupMessage builds. Drop the
+    // "already distributed" record first, or the resend would carry the same
+    // bare skmsg the recipient just told us it could not read.
+    // Carry the round count into the resend so its own retry receipts continue
+    // the same chain instead of restarting it at zero.
+    const opts = Object.assign({}, cached.options, { _retryDepth: depth });
+
+    if (cached.isGroup) {
+      const resendId = generateMessageId();
+      if (this._signal && this._signal.senderKeyStore) {
+        this._signal.senderKeyStore.invalidateSKDM(cached.toJid);
+      }
+      _whaDbg('[DBG] RETRY_RESEND group round=' + depth + ' newId=' + resendId + '\n');
+      this._sender._sendGroupMessage(
+        cached.toJid, resendId, cached.plaintext, cached.mediaType, opts
+      )
+        .then(r  => _whaDbg('[DBG] RETRY_RESEND group ok id=' + (r && r.id) + '\n'))
+        .catch(e => _whaDbg('[DBG] RETRY_RESEND_ERR: ' + e.message));
+      return;
+    }
+
     this._sender._sendDMMessage(
-      cached.toJid, cached.msgId, cached.plaintext, cached.mediaType, cached.options
+      cached.toJid, cached.msgId, cached.plaintext, cached.mediaType, opts
     )
       .then(r  => _whaDbg('[DBG] RETRY_RESEND ok id=' + r.id + '\n'))
       .catch(e => _whaDbg('[DBG] RETRY_RESEND_ERR: ' + e.message));

package/lib/DeviceManager.js

@@ -305,30 +305,15 @@ class DeviceManager {
   async fetchBundles(jids) {
     if (!jids || jids.length === 0) return new Map();
 
-    // Convert a string JID like "user@server" or "user:device@server" into
-    // a proper JID object so the binary encoder uses JID_PAIR / AD_JID format.
-    // Raw UTF-8 strings are NOT recognised by the WA server for @lid JIDs — the
-    // server silently ignores unknown JIDs and returns an empty bundle list.
-    const toJidObj = jidStr => {
-      const str    = typeof jidStr === 'string' ? jidStr : String(jidStr);
-      const at     = str.indexOf('@');
-      const raw    = at >= 0 ? str.slice(0, at) : str;
-      const server = at >= 0 ? str.slice(at + 1) : 's.whatsapp.net';
-      const colon  = raw.indexOf(':');
-      const user   = colon >= 0 ? raw.slice(0, colon) : raw;
-      const device = colon >= 0 ? (parseInt(raw.slice(colon + 1), 10) || 0) : 0;
-      const self   = str;
-      // AD_JID binary format is for @s.whatsapp.net with device > 0.
-      // JID_PAIR binary format is used for @lid and for device-0 @s.whatsapp.net.
-      if (server === 's.whatsapp.net' && device > 0) {
-        // AD_JID: agent=0, device=N
-        return { user, agent: 0, device, server, toString() { return self; } };
-      }
-      // JID_PAIR: user@server  — server may be 'lid' or 's.whatsapp.net'
-      return { user, server, toString() { return self; } };
-    };
-
-    const userNodes = jids.map(jid => new BinaryNode('user', { jid: toJidObj(jid) }, null));
+    // Use the shared converter. The local copy this replaced dropped the device
+    // suffix on @lid JIDs: it split "112713111982325:49@lid" into user and
+    // device, then fell through to a JID_PAIR built from `user` alone, so every
+    // device of a contact encoded to the identical "112713111982325@lid". The
+    // server saw one repeated JID, returned a single device-0 bundle, and no
+    // session was ever built for the other devices — leaving them unable to
+    // decrypt anything we sent. jidStrToObj keeps the colon inside the user
+    // part for @lid, which is what the server expects.
+    const userNodes = jids.map(jid => new BinaryNode('user', { jid: jidStrToObj(jid) }, null));
     const iqId   = this._client._genMsgId();
     const iqNode = new BinaryNode('iq',
       { id: iqId, xmlns: 'encrypt', type: 'get', to: 's.whatsapp.net' },

package/lib/messages/MessageSender.js

@@ -772,7 +772,8 @@ class MessageSender {
     // Cache plaintext so Client can re-send with fresh session on recipient retry
     if (this._client._sentMsgCache) {
       this._client._sentMsgCache.set(msgId, {
-        plaintext, toJid, msgId, mediaType, options, recipientPhone
+        plaintext, toJid, msgId, mediaType, options, recipientPhone,
+        retryDepth: options._retryDepth || 0
       });
       // Keep cache bounded — evict oldest entries beyond 200
       if (this._client._sentMsgCache.size > 200) {
@@ -973,6 +974,22 @@ class MessageSender {
     };
     if (options.edit) stanzaAttrs.edit = String(options.edit);
 
+    // Cache the plaintext here too, not just on the DM path. A group recipient
+    // that cannot decrypt sends a retry receipt exactly like a DM recipient
+    // does, and without this the client had nothing to re-send and dropped it
+    // with "no cached plaintext" — so the message was acked by the server and
+    // then silently never arrived.
+    if (this._client._sentMsgCache) {
+      this._client._sentMsgCache.set(msgId, {
+        plaintext, toJid: groupJid, msgId, mediaType, options, isGroup: true,
+        retryDepth: options._retryDepth || 0
+      });
+      if (this._client._sentMsgCache.size > 200) {
+        const firstKey = this._client._sentMsgCache.keys().next().value;
+        this._client._sentMsgCache.delete(firstKey);
+      }
+    }
+
     const msgNode = new BinaryNode('message', stanzaAttrs, msgContent);
     return this._dispatchAndAck(msgNode, msgId);
   }

package/package.json

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