whalibmob 5.7.2 → 5.7.3

package/lib/Client.js

@@ -1904,8 +1904,43 @@ class WhalibmobClient extends EventEmitter {
     const { normalizeJidForTcToken } = require('./messages/TcTokenStore');
     const norm = normalizeJidForTcToken(jid);
     if (norm.endsWith('@lid')) return norm;
-    const lidUser = this._pnToLid && this._pnToLid.get(norm.split('@')[0]);
-    return lidUser ? lidUser + '@lid' : norm;
+
+    const pnUser = norm.split('@')[0];
+    let lidUser = this._pnToLid && this._pnToLid.get(pnUser);
+
+    // The in-memory map starts empty and is filled by usync and by incoming
+    // messages, so a send early in a process — or one that hits a warm device
+    // cache and never runs usync — could find nothing and fall back to the
+    // phone JID. The mapping is on disk in the Signal store either way, which
+    // is the same place whatsmeow reads it from, so consult that before giving
+    // up. The consequence of not doing so is not cosmetic: the lookup lands on
+    // a key with no token while a live one sits under the LID, and the message
+    // goes out without one.
+    if (!lidUser) {
+      const store = this._signal && this._signal.store;
+      const persisted = store && typeof store.getLidMappings === 'function'
+        ? store.getLidMappings() : null;
+      const fromDisk = persisted && persisted[pnUser];
+      if (fromDisk) {
+        lidUser = String(fromDisk);
+        if (this._pnToLid) this._pnToLid.set(pnUser, lidUser);
+        if (this._lidToPn) this._lidToPn.set(lidUser, pnUser);
+        _whaDbg('[DBG] TCTOKEN_LID_FROM_DISK pn=' + pnUser + ' lid=' + lidUser);
+      }
+    }
+
+    if (!lidUser) return norm;
+
+    const lidJid = lidUser + '@lid';
+
+    // Anything already filed under the phone JID belongs with the LID entry.
+    // Left split, the two halves each hold part of the state and neither is
+    // complete. Cheap when there is nothing to move, which is the usual case.
+    if (this._tcTokenStore && this._tcTokenStore.mergeEntry(norm, lidJid)) {
+      _whaDbg('[DBG] TCTOKEN_MERGED ' + norm + ' → ' + lidJid);
+    }
+
+    return lidJid;
   }
 
   // The JID a token is *issued* to, which is not the JID it is *stored* under.

package/lib/messages/TcTokenStore.js

@@ -166,6 +166,50 @@ class TcTokenStore {
     return true;
   }
 
+  /**
+   * Fold an entry filed under one JID into the entry for another.
+   *
+   * The same contact can end up with two entries — one under their phone JID
+   * and one under their LID — when a send happens before the LID mapping is
+   * known. That is not just untidy: whichever key the next send resolves to is
+   * the only one it looks at, so a live token under the LID goes unused and the
+   * message ships without one.
+   *
+   * The live token wins, newest first. The sender timestamp takes the newer of
+   * the two, since an older one would say we are due to issue again when we are
+   * not.
+   *
+   * @returns {boolean} whether anything was moved
+   */
+  mergeEntry(fromJid, toJid) {
+    const fromKey = normalizeJidForTcToken(fromJid);
+    const toKey   = normalizeJidForTcToken(toJid);
+    if (fromKey === toKey) return false;
+
+    const from = this._map.get(fromKey);
+    if (!from) return false;
+
+    const to = this._map.get(toKey) || {};
+
+    const fromLive = !!(from.token && from.token.length) && !tcTokenExpired(from.timestamp);
+    const toLive   = !!(to.token   && to.token.length)   && !tcTokenExpired(to.timestamp);
+
+    let token     = to.token != null ? to.token : null;
+    let timestamp = to.timestamp != null ? to.timestamp : null;
+    if (fromLive && (!toLive || Number(from.timestamp) > Number(to.timestamp || 0))) {
+      token     = from.token;
+      timestamp = from.timestamp;
+    }
+
+    const senderTimestamp =
+      Math.max(Number(to.senderTimestamp || 0), Number(from.senderTimestamp || 0)) || null;
+
+    this._map.set(toKey, { token, timestamp, senderTimestamp });
+    this._map.delete(fromKey);
+    this._save();
+    return true;
+  }
+
   clearToken(jid) {
     const key      = normalizeJidForTcToken(jid);
     const existing = this._map.get(key) || {};

package/package.json

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