whalibmob 5.14.6 → 5.14.7

package/lib/Client.js

@@ -171,6 +171,17 @@ const PING_INTERVAL_MS    = 25000;
 const KEEPALIVE_INTERVAL  = 20000;
 const RECONNECT_BACKOFF   = [1000, 2000, 4000, 8000, 15000, 30000];
 
+// When the server is down to this many one-time keys or fewer, send it more.
+// The number is small on purpose: the server tells us when it is running low,
+// and this is the floor for the case where that notice never arrives.
+const PRE_KEY_SERVER_MIN  = 5;
+
+// How often to ask the server how many it has left. The drain is invisible from
+// here — every bundle handed out is a key gone, and none of that reaches this
+// side — so on a session that stays up for days this is the only thing that
+// notices before the pool is empty and the account stops being reachable.
+const PRE_KEY_CHECK_INTERVAL = 30 * 60 * 1000;   // 30 minutes
+
 // ─── Key helpers ──────────────────────────────────────────────────────────────
 
 function intToBytes(n, byteLen) {
@@ -1234,7 +1245,9 @@ class WhalibmobClient extends EventEmitter {
     this.setOnline(true);
 
     this._requestMediaConnection();
-    this._uploadPreKeys();
+    // Ask what the server still has rather than uploading blind. It answers
+    // with a number this side has no other way of learning.
+    this._ensureServerPreKeys('login');
 
     // Same telemetry ping the web client sends on every completed login.
     this._sendUnifiedSession();
@@ -1500,9 +1513,23 @@ class WhalibmobClient extends EventEmitter {
     }
 
     if (collections.size === 0) return;
-    this.syncAppState([...collections]).catch(err => {
-      _whaDbg('[DBG] APP_STATE sync failed: ' + (err && err.message));
-    });
+
+    // The bit has to be cleared whatever came of the sync. A session that
+    // cannot sync at all — no key has ever been shared with it, which is every
+    // session that registered its own number — would otherwise leave it set
+    // forever and be told about the same change on every single connection.
+    const clearAll = () => {
+      for (const type of dirtyTypes) {
+        if (COLLECTION_MAP[type]) this._cleanDirtyBits(type);
+      }
+    };
+
+    this.syncAppState([...collections])
+      .then(clearAll)
+      .catch(err => {
+        _whaDbg('[DBG] APP_STATE sync failed: ' + (err && err.message));
+        clearAll();
+      });
   }
 
   /**
@@ -1920,11 +1947,20 @@ class WhalibmobClient extends EventEmitter {
         }, [new BinaryNode('ping', {}, null)]));
       }
     }, KEEPALIVE_INTERVAL);
+
+    // The server is supposed to say when it is running out of one-time keys,
+    // and mostly does. This is for when it does not: a session that stays up
+    // long enough can be drained without a word, and the first sign of it is
+    // that nobody can reach the account any more.
+    this._preKeyTimer = setInterval(() => {
+      if (this._socket && this._connected) this._ensureServerPreKeys('periodic');
+    }, PRE_KEY_CHECK_INTERVAL);
   }
 
   _stopTimers() {
-    if (this._pingTimer) { clearInterval(this._pingTimer); this._pingTimer = null; }
-    if (this._keepTimer) { clearInterval(this._keepTimer); this._keepTimer = null; }
+    if (this._pingTimer)   { clearInterval(this._pingTimer);   this._pingTimer   = null; }
+    if (this._keepTimer)   { clearInterval(this._keepTimer);   this._keepTimer   = null; }
+    if (this._preKeyTimer) { clearInterval(this._preKeyTimer); this._preKeyTimer = null; }
   }
 
   // ─── Node dispatch ────────────────────────────────────────────────────────
@@ -3005,15 +3041,28 @@ class WhalibmobClient extends EventEmitter {
       // whole dispatch down with it, so every notification behind it in the
       // offline queue was dropped too.
       const fromJid   = String(attrs.from || '');
-      const fromPhone = fromJid.split('@')[0].split(':')[0];
-      if (fromPhone && this._devMgr) {
-        this._devMgr._dcDel([fromPhone]);
-        _whaDbg('[DBG] NOTIF_DEVICES invalidated cache for ' + fromPhone);
+      const fromUser  = fromJid.split('@')[0].split(':')[0];
+      // The user segment of a LID is not a phone number, and usync only takes
+      // phone numbers — asking it about a LID comes back "invalid" and the
+      // device list is never actually refreshed. Translate first when we know
+      // the mapping, and when we do not, invalidate the cache and stop there
+      // rather than spending an IQ on a question that cannot be answered.
+      const isLid     = fromJid.endsWith('@lid');
+      const mappedPn  = isLid && this._lidToPn ? this._lidToPn.get(fromUser) : null;
+      const fromPhone = isLid ? mappedPn : fromUser;
+      if (fromUser && this._devMgr) {
+        this._devMgr._dcDel(isLid ? [fromUser, 'lid:' + fromUser] : [fromUser]);
+        if (mappedPn) this._devMgr._dcDel([mappedPn]);
+        _whaDbg('[DBG] NOTIF_DEVICES invalidated cache for ' + fromUser +
+          (isLid ? (mappedPn ? ' (lid → ' + mappedPn + ')' : ' (lid, no phone known)') : ''));
         // Also process any inline <devices> list the server included
         const devicesNode = findChildDeep(node, 'devices');
         if (devicesNode) this._processDeviceUpdate(devicesNode);
-        // Background re-usync so the cache is warm before the next send
-        if (this._signal) {
+        // Background re-usync so the cache is warm before the next send. Only
+        // when there is a phone number to ask about — the cache is already
+        // cleared, so a LID with no known number simply gets looked up the next
+        // time something sends to it.
+        if (this._signal && fromPhone) {
           setImmediate(() => {
             if (!this._connected || !this._devMgr) return;
             this._devMgr.bulkEnsureSessions([fromPhone], this._signal, false)
@@ -3320,15 +3369,90 @@ class WhalibmobClient extends EventEmitter {
     ]));
   }
 
-  _checkAndReplenishPreKeys() {
+  // How many one-time keys the server is still holding for us.
+  //
+  // This is the number that matters and the one we could not see. The local
+  // store only loses a key when a pkmsg using it is actually decrypted, while
+  // the server hands one out to everybody who asks for a bundle — including the
+  // ones who then never write. So the two drift apart, and the local count can
+  // sit at its full 800 while the server has none left. With none left nobody
+  // can open a session with this account at all: the messages are not delayed,
+  // they are never sent, which is why nothing arrives and nothing is queued.
+  //
+  // The two client families ask differently, so each is asked its own way. A
+  // companion asks for a count and is told a number. A primary asks for the
+  // digest and is given the ids it holds, which is the same answer with the
+  // arithmetic left to us.
+  async _queryServerPreKeyCount() {
+    if (!this._socket || !this._connected) return null;
+
+    const web  = this._mode === 'web';
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'get',
+      xmlns: 'encrypt'
+    }, [new BinaryNode(web ? 'count' : 'digest', {}, null)]));
+
+    if (!resp) return null;                                   // timed out
+    if (resp.attrs && resp.attrs.type === 'error') return null;
+
+    if (web) {
+      const countNode = findChild(resp, 'count');
+      const value     = countNode && countNode.attrs && countNode.attrs.value;
+      const n         = value === undefined ? NaN : Number(value);
+      return Number.isFinite(n) ? n : null;
+    }
+
+    // <digest><list><...one child per key we still have there...></list></digest>
+    const digest = findChild(resp, 'digest');
+    const list   = digest && findChild(digest, 'list');
+    if (!list) return null;
+    return Array.isArray(list.content) ? list.content.length : 0;
+  }
+
+  // Top the server back up when it is running out. Never throws: a session that
+  // cannot ask is left exactly as it was rather than losing its connection over
+  // a bookkeeping query.
+  async _ensureServerPreKeys(reason) {
     if (!this._signal) return;
-    const count = this._signal.preKeyCount();
-    if (count < 20) {
-      const newKeys = this._signal.replenishPreKeys();
-      if (newKeys.length > 0) this._uploadPreKeys();
+    try {
+      const serverCount = await this._queryServerPreKeyCount();
+      if (serverCount === null) {
+        // No usable answer. Fall back to the old behaviour — an upload we may
+        // not have needed costs nothing next to an account nobody can reach.
+        _whaDbg('[DBG] PREKEY server count unavailable (' + reason + ') — uploading anyway');
+        this._replenishLocalPreKeys();
+        this._uploadPreKeys();
+        return;
+      }
+
+      _whaDbg('[DBG] PREKEY server holds ' + serverCount + ' (' + reason + ')');
+      if (serverCount > PRE_KEY_SERVER_MIN) return;
+
+      _whaDbg('[DBG] PREKEY server low (' + serverCount + ' <= ' + PRE_KEY_SERVER_MIN +
+        ') — uploading');
+      this._replenishLocalPreKeys();
+      this._uploadPreKeys();
+    } catch (err) {
+      _whaDbg('[DBG] PREKEY check failed (' + reason + '): ' + (err && err.message));
     }
   }
 
+  // Make sure there is something to upload before uploading.
+  _replenishLocalPreKeys() {
+    if (!this._signal) return;
+    if (this._signal.preKeyCount() < 20) this._signal.replenishPreKeys();
+  }
+
+  _checkAndReplenishPreKeys() {
+    if (!this._signal) return;
+    // The server said it is running low, so ask it how low and act on that
+    // rather than on the local count, which does not move when the server
+    // hands a key out.
+    this._ensureServerPreKeys('server asked');
+  }
+
   // ─── IQ helper (send + await response) ────────────────────────────────────
 
   _sendIq(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.14.6",
+  "version": "5.14.7",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API and web ",
   "author": "Kunboruto20",
   "main": "index.js",