whalibmob 5.9.0 → 5.9.2

package/README.md

@@ -1112,6 +1112,7 @@ connect()
 | `app_state_sync` | `{ collections, applied }` | An app-state sync finished; see [Reading Changes Made Elsewhere](#app-state-sync) |
 | `app_state_mutation` | `{ collection, index, action, removed }` | An app-state change this library does not model |
 | `app_state_key_missing` | `{ collection, keyId }` | App state cannot be read until your phone shares this key |
+| `app_state_keys` | `{ keys }` | Your phone shared app-state sync keys; a sync starts automatically |
 
 `remote: true` on a chat event means the change was made on your phone or another
 linked device rather than by this session. Your own calls carry `synced` instead,

package/cli.js

@@ -600,6 +600,13 @@ function attachEvents(client) {
     _rl && (_rl.resume(), _rl.prompt(true));
   });
 
+  client.on('app_state_keys', (e) => {
+    _rl && _rl.pause();
+    out('  app state: received ' + e.keys.length + ' sync key(s) from your phone —' +
+        ' pins, archives, mutes and stars will sync from now on');
+    _rl && (_rl.resume(), _rl.prompt(true));
+  });
+
   client.on('decrypt_error', (e) => {
     _rl && _rl.pause();
     out('  DECRYPT_ERROR  from ' + e.from + '  id ' + e.id + '  : ' + (e.err && e.err.message));

package/lib/Client.js

@@ -51,8 +51,8 @@ const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
 const INVITE_LINK_PREFIX = 'https://chat.whatsapp.com/';
 
 // The names privacy settings actually go by on the wire, and the friendly
-// aliases this library has always accepted for them. whatsmeow's
-// PrivacySettingType constants are the right-hand column.
+// aliases this library has always accepted for them. The wire names are the
+// right-hand column.
 const PRIVACY_NAME_ALIASES = {
   last_seen: 'last',            last: 'last',
   profile_picture: 'profile',   profile_pic: 'profile',    profile: 'profile',
@@ -80,8 +80,8 @@ const PRIVACY_WIRE_TO_KEY = {
   stickers:     'stickers'
 };
 
-// Reduce a JID to its bare user — whatsmeow's ToNonAD. Blocking, and anything
-// else that names an account rather than one of its devices, wants this form.
+// Reduce a JID to its bare user. Blocking, and anything else that names an
+// account rather than one of its devices, wants this form.
 function toNonAdJid(input) {
   const s      = String(input || '');
   const at     = s.indexOf('@');
@@ -246,14 +246,14 @@ class WhalibmobClient extends EventEmitter {
     this._tcTokenStore            = null; // TcTokenStore — loaded in init()
     this._inFlightTcTokenIssuance = new Set(); // dedupe concurrent proactive issuePrivacyTokens per JID
     this._inFlight463Recoveries   = new Set(); // dedupe concurrent 463-triggered token issuances per JID (separate from proactive)
-    // Blue-tick every message as it arrives. Set to false for whatsmeow's model,
-    // where read is only ever sent by an explicit markRead() call.
+    // Blue-tick every message as it arrives. Set to false to make read receipts
+    // explicit, sent only by a markRead() call.
     this.autoRead = opts.autoRead !== false;
     // Flipped by setOnline(). Delivery receipts sent while this is false carry
     // type="inactive", which the sender's app records but does not render.
     this._sendActiveReceipts = false;
-    // Cached privacy settings, as whatsmeow caches them. Warmed after connect
-    // and refreshed whenever the server reports a change; markRead reads it.
+    // Cached privacy settings. Warmed after connect and refreshed whenever the
+    // server reports a change; markRead reads it.
     this._privacySettings = null;
     if (opts.pino !== undefined) _whaConfigLogger(opts.pino);
   }
@@ -731,9 +731,9 @@ class WhalibmobClient extends EventEmitter {
       this._saveWebStore();
       _whaDbg('[DBG] COMPANION_FINISH adv_secret derived');
 
-      // Baileys awaits this one rather than firing and forgetting, so a server
-      // rejection surfaces as an error here instead of as a silent stall
-      // waiting for a pair-success that is never coming.
+      // Awaited rather than fired and forgotten, so a server rejection surfaces
+      // as an error here instead of as a silent stall waiting for a
+      // pair-success that is never coming.
       const finishResult = await this._sendIq(new BinaryNode('iq', {
         to:    's.whatsapp.net',
         type:  'set',
@@ -1810,10 +1810,9 @@ class WhalibmobClient extends EventEmitter {
     // Companion pairing — these arrive unsolicited, so they are checked before
     // the pending-IQ table rather than after it.
     //
-    // pair-device is matched on type=set; pair-success is matched on any type,
-    // the way Baileys distinguishes them ('CB:iq,type:set,pair-device' against
-    // a bare 'CB:iq,,pair-success'). Requiring type=set on pair-success would
-    // drop the stanza that completes the link.
+    // pair-device is matched on type=set; pair-success is matched on any type.
+    // Requiring type=set on pair-success would drop the stanza that completes
+    // the link.
     if (this._mode === 'web') {
       if (type === 'set' && findChild(node, 'pair-device')) { this._handlePairDevice(node);  return; }
       if (findChild(node, 'pair-success'))                  { this._handlePairSuccess(node); return; }
@@ -1984,13 +1983,13 @@ class WhalibmobClient extends EventEmitter {
         if (decoded.type === 'protocol') {
           _whaDbg('[DBG] PROTO subtype=' + decoded.subtype + ' id=' + id);
 
-          // ── HISTORY_SYNC_NOTIFICATION ─────────────────────────────────────
-          if (decoded.subtype === 'history_sync' && decoded.historySyncNotification) {
+          // Keyed off what the message actually carried rather than off the
+          // type that announced it. A payload that is present is the payload,
+          // whatever the type number turns out to mean.
+          if (decoded.historySyncNotification) {
             this._handleHistorySync(decoded.historySyncNotification, id);
           }
-
-          // ── APP_STATE_SYNC_KEY_SHARE ──────────────────────────────────────
-          if (decoded.subtype === 'app_state_sync_key_share' && decoded.appStateSyncKeyShare) {
+          if (decoded.appStateSyncKeyShare) {
             this._handleAppStateSyncKeyShare(decoded.appStateSyncKeyShare);
           }
 
@@ -2001,8 +2000,8 @@ class WhalibmobClient extends EventEmitter {
         this._sendReadReceipt(id, fromRaw, partRaw);
 
         // ── pkmsg = peer opened a new Signal session (identity/device change) ──
-        // Re-issue our tcToken to them so the fresh session carries a valid token.
-        // Mirrors Baileys' reissueTcTokenAfterIdentityChange (messages-recv.js).
+        // Re-issue our tcToken to them so the fresh session carries a valid
+        // token.
         if (encType === 'pkmsg' && this._tcTokenStore) {
           this._reissueTcTokenAfterIdentityChange(sigJid);
         }
@@ -2025,10 +2024,10 @@ class WhalibmobClient extends EventEmitter {
         const decoded = this._decodeMsg(plaintext);
         if (decoded.type === 'senderKeyDistribution') return;
         if (decoded.type === 'protocol') {
-          if (decoded.subtype === 'history_sync' && decoded.historySyncNotification) {
+          if (decoded.historySyncNotification) {
             this._handleHistorySync(decoded.historySyncNotification, id);
           }
-          if (decoded.subtype === 'app_state_sync_key_share' && decoded.appStateSyncKeyShare) {
+          if (decoded.appStateSyncKeyShare) {
             this._handleAppStateSyncKeyShare(decoded.appStateSyncKeyShare);
           }
           return;
@@ -2250,10 +2249,10 @@ class WhalibmobClient extends EventEmitter {
   }
 
   // A read receipt only tells the sender we read it when read receipts are on.
-  // whatsmeow's MarkRead checks the same setting and downgrades "read" to
-  // "read-self", which marks the message read across our own devices without
-  // reporting it to the other side. Nothing here looked at the setting, so a
-  // user who had turned read receipts off still sent blue ticks.
+  // With them off, "read" is downgraded to "read-self", which marks the message
+  // read across our own devices without reporting it to the other side. Nothing
+  // here looked at the setting, so a user who had turned read receipts off
+  // still sent blue ticks.
   _readReceiptType(base) {
     const settings = this._privacySettings;
     if (settings && settings.readReceipts === 'none' && base === 'read') {
@@ -2264,9 +2263,8 @@ class WhalibmobClient extends EventEmitter {
 
   // The key a privacy token is stored and looked up under.
   //
-  // Both references resolve it to the contact's LID and fall back to the plain
-  // JID only when no LID is known — whatsmeow's resolveTCTokenStorageLID and
-  // Baileys' resolveTcTokenJid are the same three lines:
+  // It resolves to the contact's LID, falling back to the plain JID only when
+  // no LID is known:
   //
   //     if (isLidUser(jid)) return jid
   //     const lid = await getLIDForPN(jid)
@@ -2289,9 +2287,9 @@ class WhalibmobClient extends EventEmitter {
     // 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
+    // phone JID. The mapping is on disk in the Signal store either way, 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) {
@@ -2325,9 +2323,8 @@ class WhalibmobClient extends EventEmitter {
   //
   // Storage is always the LID. Issuance follows AB prop 14303
   // (lid_trusted_token_issue_to_lid), whose WA Web default is off — so the IQ
-  // names the phone JID. Baileys implements exactly this in resolveIssuanceJid
-  // and defaults the prop to false; whatsmeow issues to the LID instead. We
-  // follow WA Web, and more importantly we now follow it in one place: the
+  // names the phone JID. We follow WA Web, and more importantly we now follow
+  // it in one place: the
   // send path, the 463 recovery and the post-identity-change re-issue used to
   // each pick a different address family for the same contact.
   _resolveTcTokenIssuanceJid(jid) {
@@ -2340,9 +2337,9 @@ class WhalibmobClient extends EventEmitter {
 
   // The one way to read a token that is safe to put on the wire.
   //
-  // whatsmeow funnels every attach site through ensureTCToken, which returns
-  // nothing for an expired token. whalibmob had the expiry check on the message
-  // path only; presence subscribe, group create, participant add and the
+  // Every attach site goes through here, and an expired token returns nothing.
+  // The expiry check used to be on the message path only; presence subscribe,
+  // group create, participant add and the
   // profile-picture query each tested `token.length` and nothing else, so once
   // a token aged past the 28-day window those four kept sending it. Same rule
   // everywhere now, and the dead token gets cleared on the way out.
@@ -2373,10 +2370,10 @@ class WhalibmobClient extends EventEmitter {
   // Delivery receipt — the sender's two grey ticks.
   //
   // Distinct from the <ack> above: the ack tells the server we took the stanza,
-  // the receipt tells the sender it reached a device. whatsmeow sends both for
-  // every incoming message (sendAck + sendMessageReceipt) and leaves the blue
-  // ticks to an explicit MarkRead. whalibmob only ever sent the ack and then
-  // jumped straight to type="read", so a sender never saw the grey stage.
+  // the receipt tells the sender it reached a device. Both go out for every
+  // incoming message, with the blue ticks left to markRead. Only the ack used
+  // to be sent, jumping straight to type="read", so a sender never saw the grey
+  // stage.
   //
   // A client that has not marked itself available sends this with
   // type="inactive": the sender's app records the delivery but does not render
@@ -2399,7 +2396,7 @@ class WhalibmobClient extends EventEmitter {
   //
   // Sent automatically after a message decodes unless autoRead is turned off, in
   // which case marking a chat read is up to the caller via markRead(). Turning
-  // it off gives whatsmeow's model, where read is always explicit.
+  // it off makes read receipts always explicit.
   // fromJid / partJid are raw JID objects (AD_JID encoding for correct routing).
   _sendReadReceipt(msgId, fromJid, partJid) {
     if (!this._socket || !this._connected) return;
@@ -2543,8 +2540,8 @@ class WhalibmobClient extends EventEmitter {
   }
 
   // <blocklist action="..." dhash="..." prev_dhash="..."><item jid=... action=.../></blocklist>
-  // Mirrors whatsmeow's handleBlocklist: the action on the node describes the
-  // whole change, each child names one JID and what happened to it.
+  // The action on the node describes the whole change; each child names one JID
+  // and what happened to it.
   _handleBlocklistNotification(node) {
     const attrs   = node.attrs || {};
     const changes = [];
@@ -2587,9 +2584,9 @@ class WhalibmobClient extends EventEmitter {
       // blocked only ever changed when it did the blocking itself.
       const blocklistNode = findChildDeep(node, 'blocklist');
       if (blocklistNode) this._handleBlocklistNotification(blocklistNode);
-      // ...and privacy setting changes, which arrive the same way. whatsmeow
-      // re-reads the settings on this and raises an event; nothing was watching
-      // the node, so a change made on the phone never reached the cache.
+      // ...and privacy setting changes, which arrive the same way. The settings
+      // are re-read on this and an event raised; nothing was watching the node,
+      // so a change made on the phone never reached the cache.
       const privacyNode = findChildDeep(node, 'privacy');
       if (privacyNode) this._handlePrivacySettingsNotification(privacyNode);
     }
@@ -2847,9 +2844,9 @@ class WhalibmobClient extends EventEmitter {
       return;
     }
 
-    // Not every failure kills the session. whatsmeow's IsLoggedOut() marks the
-    // ones that do — 401, 403, 405, 406, 409 — and treats the rest as worth
-    // another attempt. A 500 or a 503 is the server having a bad minute; giving
+    // Not every failure kills the session. These five do — 401, 403, 405, 406,
+    // 409 — and the rest are worth another attempt. A 500 or a 503 is the
+    // server having a bad minute; giving
     // up on the session for that would be throwing away a working registration.
     const LOGGED_OUT = ['401', '403', '405', '406', '409'];
     const spent = LOGGED_OUT.includes(reason);
@@ -3289,8 +3286,6 @@ class WhalibmobClient extends EventEmitter {
    * Send a `<iq type='set' xmlns='privacy'>` to issue a trusted-contact token
    * for `jid`. Returns the raw result node (or null on timeout).
    *
-   * Mirrors Baileys' `issuePrivacyTokens` in messages-send.js.
-   *
    * @param {string} jid          - Bare or full JID of the conversation partner
    * @param {number} timestamp    - Unix seconds to use as the token timestamp
    */
@@ -3378,13 +3373,12 @@ class WhalibmobClient extends EventEmitter {
                         : (typeof tokenNode.content === 'string' && tokenNode.content.length > 0)
                           ? Buffer.from(tokenNode.content, 'base64')
                           : null;
-          // Baileys tc-token-utils.js line 137-138:
-          // "In notifications tokenNode.attrs.jid is your own device JID, not the sender's"
-          // → always prefer fallbackJid; only fall back to a.jid when fallbackJid is absent
+          // In a notification, tokenNode.attrs.jid is our own device JID rather
+          // than the sender's, so fallbackJid wins whenever it is present.
           const jid = fallbackJid || String(a.jid);
           const t   = a.t   ? parseInt(String(a.t), 10) : issueTs;
-          // Baileys drops anything that is not a regular user here — the guard
-          // is against a malformed or spoofed notification filing a token under
+          // Anything that is not a regular user is dropped here, guarding
+          // against a malformed or spoofed notification filing a token under
           // the PSA account or a bot.
           if (!isRegularTcTokenUser(jid)) {
             _whaDbg('[DBG] STORE_TCTOKEN skipped non-user jid=' + jid);
@@ -3407,8 +3401,8 @@ class WhalibmobClient extends EventEmitter {
       }
     }
 
-    // ── CRITICAL: Baileys ALWAYS persists senderTimestamp after issuing, ─────
-    // ── regardless of whether server returned token bytes.               ─────
+    // ── CRITICAL: senderTimestamp is ALWAYS persisted after issuing,     ─────
+    // ── regardless of whether the server returned token bytes.           ─────
     // ── Without this, shouldSendNewTcToken() returns true every send and ─────
     // ── we flood the server with privacy IQs.                            ─────
     // ── For incoming privacy_token notifications saveSenderTs=false so  ─────
@@ -3427,14 +3421,14 @@ class WhalibmobClient extends EventEmitter {
   /**
    * Handle a server-pushed `<notification type='privacy_token'>`.
    *
-   * Wire format (mirrors Baileys' handlePrivacyTokenNotification):
+   * Wire format:
    *   <notification type='privacy_token' from='...' [sender_lid='...@lid']>
    *     <tokens>
    *       <token type='trusted_contact' jid='...' t='...'>…bytes…</token>
    *     </tokens>
    *   </notification>
    *
-   * Key rules (from Baileys messages-recv.js lines 996-1015):
+   * Key rules:
    *   1. Must find <tokens> wrapper inside notification; abort if absent.
    *   2. storage key = sender_lid (if present and @lid) else PN→LID lookup else from-JID.
    *   3. senderTimestamp is NOT updated here — only the peer-token bytes + timestamp.
@@ -3449,7 +3443,7 @@ class WhalibmobClient extends EventEmitter {
     _whaDbg('[DBG] PRIVACY_TOKEN_NOTIF_ENTER from=' + String(attrs.from || '') +
       ' sender_lid=' + String(attrs.sender_lid || ''));
 
-    // ── 1. Require <tokens> wrapper (matches Baileys' getBinaryNodeChild check) ──
+    // ── 1. Require the <tokens> wrapper ────────────────────────────────────────
     const content    = Array.isArray(node.content) ? node.content : [];
     const tokensNode = content.find(n => n && n.description === 'tokens');
     if (!tokensNode) {
@@ -3458,7 +3452,7 @@ class WhalibmobClient extends EventEmitter {
     }
 
     // ── 2. Resolve storage JID ─────────────────────────────────────────────────
-    // Priority (mirrors Baileys lines 1001-1006):
+    // Priority:
     //   1. sender_lid attr if it is a @lid JID
     //   2. from user is a known LID user (LID comes as @s.whatsapp.net in notification)
     //   3. from is a PN → look up LID in _pnToLid
@@ -3494,7 +3488,7 @@ class WhalibmobClient extends EventEmitter {
    * Called when we successfully decrypt a pkmsg — the peer opened a fresh Signal
    * session (reset or new device), so we re-issue a privacy token so they can
    * reach us.  Only fires if we've previously issued a token (senderTimestamp
-   * present and not expired), mirroring Baileys' reissueTcTokenAfterIdentityChange.
+   * present and not expired).
    *
    * @param {string} from  - Signal-session JID (PN or LID JID of the sender)
    */
@@ -3516,8 +3510,8 @@ class WhalibmobClient extends EventEmitter {
         _whaDbg('[DBG] REISSUE_TC_TOKEN_AFTER_IDENTITY_CHANGE jid=' + tcJid +
           ' prevSenderTs=' + senderTs);
 
-        // Baileys re-issues with the *previous* senderTimestamp, not a fresh
-        // one, and stores the result without touching the dedupe state. That
+        // The re-issue carries the *previous* senderTimestamp, not a fresh one,
+        // and the result is stored without touching the dedupe state. That
         // matters: this is a repair of an existing grant after the peer's
         // device changed, not a new grant, so it must not move the 7-day
         // bucket that governs regular issuance. We were stamping it with
@@ -3614,7 +3608,7 @@ class WhalibmobClient extends EventEmitter {
    *  - Skips expired tokens (no point loading a token we'd immediately discard).
    *  - Storage key follows TcTokenStore convention: normalized bare JID.
    *    For LID chats (jid ends in @lid) we use the lid JID directly.
-   *    For PN chats we try to look up the LID first (Baileys always stores under LID).
+   *    For PN chats we try to look up the LID first, since storage is by LID.
    *
    * @param {object|null} merged  - Return value of mergeHistoryToStore()
    */
@@ -3642,7 +3636,7 @@ class WhalibmobClient extends EventEmitter {
         continue;
       }
 
-      // Resolve storage JID: Baileys always stores under LID.
+      // Resolve storage JID — storage is always by LID.
       // If this chat is a @lid jid, use it directly.
       // If it's a PN jid, try to find its LID counterpart.
       let storageJid;
@@ -3700,6 +3694,15 @@ class WhalibmobClient extends EventEmitter {
     }
 
     this.emit('app_state_keys', { keys: keyShare.keys });
+
+    // The key is what app state was waiting on. Anything the server has been
+    // holding for us can be read now, so go and get it rather than sitting on
+    // it until the next dirty bit happens along.
+    if (this._connected && this._appState) {
+      this.syncAppState().catch(err => {
+        _whaDbg('[DBG] APP_STATE sync after key share failed: ' + (err && err.message));
+      });
+    }
   }
 
   /**
@@ -3792,9 +3795,9 @@ class WhalibmobClient extends EventEmitter {
   //            required in a group; type may be 'read' (default) or 'played'
   //            to mark a voice note as listened to.
   //
-  // Shaped the way whatsmeow's MarkRead builds it: the FIRST id on the receipt
-  // and the rest as <item> children of a <list> node. whalibmob used the last id
-  // and put the items straight into <receipt>, which is not a shape the server
+  // The FIRST id goes on the receipt and the rest as <item> children of a
+  // <list> node. The last id used to be used instead, with the items straight
+  // inside <receipt>, which is not a shape the server
   // reads back — the extra ids were silently ignored, so only one message per
   // call was ever marked. The participant was missing entirely, so a group read
   // never told the server whose message had been read.
@@ -3881,8 +3884,8 @@ class WhalibmobClient extends EventEmitter {
 
   // Set global online/offline status.
   //
-  // whatsmeow refuses to send this without a push name (ErrNoPushName): the
-  // server takes the display name from this node, and sending it empty makes
+  // This is refused without a push name: the server takes the display name from
+  // this node, and sending it empty makes
   // every other user see "-" instead of a name. Going available also flips the
   // client into sending active delivery receipts — see _sendDeliveryReceipt.
   //
@@ -3905,9 +3908,9 @@ class WhalibmobClient extends EventEmitter {
   // Set typing/recording presence in a specific chat.
   // presence: 'composing' | 'paused' | 'recording'
   //
-  // whatsmeow's SendChatPresence puts both `from` (our own JID) and `to` on the
-  // chatstate node and expresses recording as composing with media="audio" —
-  // there is no separate recording state in the protocol. The `from` was missing
+  // Both `from` (our own JID) and `to` go on the chatstate node, and recording
+  // is expressed as composing with media="audio" — there is no separate
+  // recording state in the protocol. The `from` was missing
   // here, and both JIDs were raw strings, which the server ignores for @lid
   // chats, so the indicator never showed for a LID-addressed contact.
   setChatPresence(chatJid, presence) {
@@ -3931,18 +3934,17 @@ class WhalibmobClient extends EventEmitter {
 
   // Subscribe to presence updates for contacts.
   //
-  // whatsmeow attaches the contact's privacy token when it has one; without it
-  // the server may decline to send their presence. It also notes that the server
-  // only forwards presence to clients that have marked themselves available, so
-  // call setOnline(true) first.
+  // The contact's privacy token is attached when there is one; without it the
+  // server may decline to send their presence. The server also only forwards
+  // presence to clients that have marked themselves available, so call
+  // setOnline(true) first.
   subscribeToPresence(jids) {
     if (!this._socket || !this._connected) return;
     const arr = Array.isArray(jids) ? jids : [jids];
     const { isRegularTcTokenUser } = require('./messages/TcTokenStore');
     for (const raw of arr) {
       const jid   = makeJid(raw);
-      // Groups and newsletters have no privacy token; Baileys guards the same
-      // way before building the node.
+      // Groups and newsletters have no privacy token.
       const token = isRegularTcTokenUser(jid) ? this._tcTokenFor(jid) : null;
       const children = token ? [new BinaryNode('tctoken', {}, token)] : null;
       this._socket.sendNode(new BinaryNode('presence', {
@@ -4049,8 +4051,8 @@ class WhalibmobClient extends EventEmitter {
     return (info && info.url) || null;
   }
 
-  // Full profile picture info, the way whatsmeow's GetProfilePictureInfo returns
-  // it: { id, url, type, directPath, hash }, or null when the user has no
+  // Full profile picture info: { id, url, type, directPath, hash }, or null
+  // when the user has no
   // picture or it has not changed since opts.existingId.
   //
   // opts: { preview, existingId, isCommunity }
@@ -4176,8 +4178,8 @@ class WhalibmobClient extends EventEmitter {
 
   // Parse the <list> a blocklist query or update comes back with.
   //
-  // whatsmeow's parseBlocklist walks every child and takes its jid, without
-  // caring what the tag is called, and keeps the dhash off the list itself.
+  // Every child is walked and its jid taken, whatever the tag is called, with
+  // the dhash kept off the list itself.
   // The JIDs are stringified here: the binary decoder hands them back as JID
   // objects, and while those print correctly they are not strings, so the array
   // this used to return failed any includes() or === against a JID string —
@@ -4310,9 +4312,9 @@ class WhalibmobClient extends EventEmitter {
   //        'none' | 'match_last_seen' | 'known' | 'on_standard' | 'off'
   // excluded: JIDs to exclude — see the note below
   //
-  // The names above are friendly aliases. What goes on the wire is what
-  // whatsmeow sends: last, profile, status, online, readreceipts, groupadd,
-  // calladd, messages, defense, stickers. Four of the six names this used to
+  // The names above are friendly aliases. What goes on the wire is: last,
+  // profile, status, online, readreceipts, groupadd, calladd, messages,
+  // defense, stickers. Four of the six names this used to
   // put on the wire — last_seen, profile_picture, read_receipts, groups_add —
   // are not names the server knows, so those settings never changed and the
   // discarded reply meant it never said so either.
@@ -4323,8 +4325,8 @@ class WhalibmobClient extends EventEmitter {
         Object.keys(PRIVACY_NAME_ALIASES).join(', '));
     }
 
-    // Neither whatsmeow nor WhatsApp Web puts <user> children on this IQ; the
-    // exclusion list is maintained separately. Kept for callers that pass it,
+    // WhatsApp Web does not put <user> children on this IQ; the exclusion list
+    // is maintained separately. Kept for callers that pass it,
     // and only emitted when they do.
     const children = [];
     if (excluded && excluded.length > 0) {
@@ -4355,8 +4357,8 @@ class WhalibmobClient extends EventEmitter {
         (code ? ' (' + code + (text ? ' ' + text : '') + ')' : ''));
     }
 
-    // whatsmeow folds the change into its cached copy and hands the whole thing
-    // back rather than making the caller re-query.
+    // The change is folded into the cached copy and the whole thing handed back
+    // rather than making the caller re-query.
     const key = PRIVACY_WIRE_TO_KEY[name];
     this._privacySettings = Object.assign({}, this._privacySettings || {},
       { [key]: String(value) });
@@ -4385,8 +4387,8 @@ class WhalibmobClient extends EventEmitter {
 
   // Who your Status posts go to.
   //
-  // Returns [{ type, isDefault, list }] with the default first, as whatsmeow's
-  // GetStatusPrivacy does. type is 'contacts', 'blacklist' or 'whitelist'; list
+  // Returns [{ type, isDefault, list }] with the default first. type is
+  // 'contacts', 'blacklist' or 'whitelist'; list
   // holds the JIDs the last two are built from. A server that has never been
   // told otherwise answers nothing, which means the default: all contacts.
   async queryStatusPrivacy() {
@@ -4427,8 +4429,8 @@ class WhalibmobClient extends EventEmitter {
   }
 
   // Resolve the status privacy settings into the JIDs a post actually goes to,
-  // the way whatsmeow's getStatusBroadcastRecipients does: a whitelist is the
-  // list itself, anything else is every known contact minus the blacklist, and
+  // a whitelist is the list itself, anything else is every known contact minus
+  // the blacklist, and
   // our own JID is added so the post lands on our own devices too.
   //
   // Contacts come from the synced history store — this client has no separate
@@ -4989,10 +4991,9 @@ class WhalibmobClient extends EventEmitter {
   //   </iq>
   //
   // The item is addressed by LID, and a block carries the phone number beside
-  // it; an unblock carries only the LID. That is the shape Baileys'
-  // updateBlockStatus builds, and the one this server accepts — whatsmeow's
-  // UpdateBlocklist still sends the plain JID it was handed, which is what this
-  // used to do and what the server answered with 400 bad-request.
+  // it; an unblock carries only the LID. That is the shape this server accepts
+  // — sending the plain JID it was handed, which is what this used to do, got a
+  // 400 bad-request back.
   //
   // Three other things were wrong with the pair this replaces. The jid went out
   // as a raw string rather than a binary JID. It was not reduced to its bare