whalibmob 5.10.3 → 5.10.6

package/README.md

@@ -1449,24 +1449,32 @@ client.on('account_restriction', (r) => {
 > client-side shortens it; the only thing that helps is not sending more
 > unanswered first messages while it is on.
 
-> [!WARNING]
-> **Some servers answer this query in Argo, not JSON.** Argo is Meta's binary
-> GraphQL encoding, and this library cannot read it. When that happens
-> `fetchReachoutTimelock()` throws with `err.mexFormat === 'argo'` and the raw
-> bytes on `err.mexPayload`.
+> [!NOTE]
+> **This transport answers in one of two encodings**, and the reply says which:
+> JSON, or Argo — Meta's compact binary encoding for GraphQL. Both are read.
+> WhatsApp sends Argo with its self-describing flag set, so it carries its own
+> field names and decodes without the GraphQL schema the query was written
+> against.
 >
-> Do not add a `format` attribute to the query in the hope of getting JSON — it
+> Do not add a `format` attribute to the query in the hope of steering this — it
 > was tried against a live server, which responded by dropping the stanza
-> entirely. An answer in a format you cannot read still beats no answer.
+> entirely and answering nothing.
+>
+> Some servers answer tersely — a bare `false` or `true` rather than the object
+> with the expiry in it. `false` is taken as "no restriction", because it is a
+> definite answer rather than a missing one. `true` sets `active` with
+> `expiryUnknown: true`, since it says there is a restriction but not when it
+> ends; the countdown then comes from the announcement.
 >
-> It never guesses. Reporting "not restricted" from an answer nobody decoded
-> would have you send more messages and make the restriction longer, so an
-> unreadable reply is an error rather than an all-clear.
+> An answer that is neither — `null`, or anything that says nothing either way —
+> throws with the decoded value on `err.mexDecoded`, rather than being reported
+> as "not restricted". An all-clear invented from an answer that never gave one
+> would have you send more messages and lengthen the very restriction you were
+> asking about.
 >
-> The `account_restriction` event is unaffected: the server *announces* a
-> restriction starting and lifting, and those announcements arrive as readable
-> JSON on a different route. Keep a listener attached and you will still be
-> told, with the countdown, without ever calling the query.
+> The `account_restriction` event does not depend on any of this. The server
+> *announces* a restriction starting and lifting, and those announcements carry
+> the countdown. Keep a listener attached and you are told either way.
 
 ### What Is Automatic vs What You Need to Do
 
@@ -2142,7 +2150,11 @@ Both methods accept a **Buffer** (use `fs.readFileSync` to load a file).
 const fs = require('fs')
 
 // change your own profile picture
-await client.changeProfilePicture(fs.readFileSync('./avatar.jpg'))
+// returns the new picture id, or 'remove' when it was taken down
+const picId = await client.changeProfilePicture(fs.readFileSync('./avatar.jpg'))
+
+// pass null to remove it
+await client.changeProfilePicture(null)
 
 // change a group's picture (you must be admin)
 // returns the new picture id, or 'remove' when the picture was taken down
@@ -2197,6 +2209,32 @@ await client.changePrivacySetting('groups_add',       'contacts')
 await client.changePrivacySetting('call_add',         'known')
 ```
 
+**Each setting takes its own values**, and they are not interchangeable:
+
+| setting | accepts |
+|---|---|
+| `last_seen`, `profile_picture`, `status`, `groups_add` | `all` · `contacts` · `contact_blacklist` · `none` |
+| `read_receipts` | `all` · `none` |
+| `online` | `all` · `match_last_seen` |
+| `call_add` | `all` · `known` |
+| `messages` | `all` · `contacts` |
+| `defense` | `on_standard` · `off` |
+| `stickers` | `contacts` · `contact_allowlist` · `none` |
+
+Friendlier words are translated: `on`, `off`, `everyone`, `nobody`,
+`my_contacts`, `contacts_except`, `contact_whitelist`. `on` becomes `all` — or
+`on_standard` for `defense`, which spells its on-state differently.
+
+```js
+await client.changePrivacySetting('read_receipts', 'on')    // sent as 'all'
+await client.changePrivacySetting('read_receipts', 'off')   // sent as 'none'
+```
+
+A value the setting does not take throws before anything is sent. This matters
+more than it looks: the server does not refuse an unknown value, it drops the
+stanza and never answers, so the mistake would otherwise surface as a timeout
+that looks like a network problem.
+
 ### Read Privacy Settings
 
 ```js
@@ -3284,20 +3322,6 @@ wa> /restriction --demo
 `--demo 90` uses ninety seconds instead of the default five hours, which is
 short enough to watch it reach zero and stop on its own.
 
-If your server encodes this answer in Argo, the command says so rather than
-guessing — and points you at the announcements, which stay readable:
-
-```sh
-wa> /restriction
-checking account restriction...
-error: mex query 23983697327930364: the server answered in "argo" rather than JSON, which this library cannot read (10 bytes: 0402300c000002010303)
-
-  The query itself worked — your server encodes this answer in a binary
-  format this library cannot read yet, so the countdown cannot be polled.
-
-  You will still be told about a restriction: the server announces one when
-  it starts and when it lifts, and those announcements do arrive readable.
-```
 
 An account that is fine says so and returns immediately:
 

package/cli.js

@@ -447,7 +447,7 @@ const HELP = `
   Profile
     /name    <text>                          change display name
     /about   <text>                          change own bio / about text
-    /photo   <file>                          change own profile picture (JPEG)
+    /photo   <file>|remove                   change or remove own profile picture (JPEG)
     /privacy [<type> <value>]                show or change privacy settings
                                                types:  last_seen profile_picture status
                                                        online read_receipts groups_add
@@ -1387,6 +1387,9 @@ async function handleLine(line) {
           out('  types:  last_seen  profile_picture  status  online  read_receipts');
           out('          groups_add  call_add  messages  defense  stickers');
           out('  values: all  contacts  contact_blacklist  contact_allowlist  none');
+          out('          not every setting takes every value — read_receipts is');
+          out('          all/none, online is all/match_last_seen. on and off are');
+          out('          accepted and translated.');
           out('          match_last_seen  known  on_standard  off');
           break;
         }
@@ -1398,11 +1401,12 @@ async function handleLine(line) {
       case '/photo': {
         requireConn();
         const file = p[1];
-        if (!file) { fail('usage: /photo <file>'); break; }
-        if (!fs.existsSync(file)) { fail('file not found: ' + file); break; }
-        const buf = fs.readFileSync(file);
-        await _client.changeProfilePicture(buf);
-        out('profile picture updated');
+        if (!file) { fail('usage: /photo <file>   (or /photo remove)'); break; }
+        if (file !== 'remove' && !fs.existsSync(file)) { fail('file not found: ' + file); break; }
+        const buf = file === 'remove' ? null : fs.readFileSync(file);
+        const picId = await _client.changeProfilePicture(buf);
+        out(picId === 'remove' ? 'profile picture removed'
+                               : 'profile picture updated' + (picId ? '  id=' + picId : ''));
         break;
       }
 
@@ -1516,19 +1520,17 @@ async function handleLine(line) {
           st = await _client.fetchReachoutTimelock();
         } catch (e) {
           fail(e.message);
-          if (e.mexFormat) {
+          if (e.mexDecoded !== undefined) {
             out('');
-            out('  The query itself worked — your server encodes this answer in a binary');
-            out('  format this library cannot read yet, so the countdown cannot be polled.');
+            out('  The reply was read, but it says nothing about a restriction either');
+            out('  way — so it is not being reported as an all-clear.');
             out('');
-            out('  You will still be told about a restriction: the server announces one when');
-            out('  it starts and when it lifts, and those announcements do arrive readable.');
-            out('  Leave the session connected and watch for:');
-            out('    ACCOUNT RESTRICTED — <reason>, HH:MM:SS remaining');
+            out('  You will still be told if one starts: the server announces that, and');
+            out('  the announcement carries the countdown.');
+          } else if (e.mexFormat) {
             out('');
-            out('  The payload above is worth keeping. Run this again while the account IS');
-            out('  restricted: the two payloads differ only where the answer differs, which');
-            out('  is what makes this format readable without its schema.');
+            out('  The query worked, but the reply is in an encoding that could not be');
+            out('  decoded. Paste the bytes above when reporting this.');
           } else {
             out('');
             out('  If the reply is sketched above, paste that line when reporting this —');

package/index.js

@@ -14,6 +14,7 @@ const { MessageSender, makeJid, generateMessageId } = require('./lib/messages/Me
 const { GroupParticipantResult, GroupJoinRequest } = require('./lib/GroupParticipant');
 const { AppStateStore, COLLECTIONS: APP_STATE_COLLECTIONS } = require('./lib/appstate/AppStateStore');
 const ReachoutTimelock = require('./lib/ReachoutTimelock');
+const { decodeArgo, tryDecodeArgo } = require('./lib/argo/ArgoDecoder');
 const AppStateSync = require('./lib/appstate/AppStateSync');
 const { PATCH_INTEGRITY: LT_HASH } = require('./lib/appstate/LTHash');
 const {
@@ -113,6 +114,9 @@ module.exports = {
   LT_HASH,
   // Account restriction
   ReachoutTimelock,
+  // Argo (the binary encoding the GraphQL transport may answer in)
+  decodeArgo,
+  tryDecodeArgo,
   // Auth utilities
   makeCacheableSignalKeyStore,
   addTransactionCapability,

package/lib/Client.js

@@ -14,6 +14,7 @@ const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts } = requi
 const { BinaryNode }      = require('./BinaryNode');
 const { AppStateStore, COLLECTIONS } = require('./appstate/AppStateStore');
 const ReachoutTimelock = require('./ReachoutTimelock');
+const { decodeArgo }   = require('./argo/ArgoDecoder');
 const AppStateSync  = require('./appstate/AppStateSync');
 const SyncdProto    = require('./appstate/SyncdProto');
 const AppMutations  = require('./appstate/Mutations');
@@ -73,6 +74,46 @@ const PRIVACY_NAME_ALIASES = {
   stickers: 'stickers'
 };
 
+// What each setting will actually accept. The server does not argue with a
+// value it does not know — it drops the stanza and never answers, so a typo
+// looks exactly like a network problem. Checking here turns that into a
+// sentence naming the choices.
+const PRIVACY_ALLOWED_VALUES = {
+  last:         ['all', 'contacts', 'contact_blacklist', 'none'],
+  profile:      ['all', 'contacts', 'contact_blacklist', 'none'],
+  status:       ['all', 'contacts', 'contact_blacklist', 'none'],
+  groupadd:     ['all', 'contacts', 'contact_blacklist', 'none'],
+  readreceipts: ['all', 'none'],
+  online:       ['all', 'match_last_seen'],
+  calladd:      ['all', 'known'],
+  messages:     ['all', 'contacts'],
+  defense:      ['on_standard', 'off'],
+  stickers:     ['contacts', 'contact_allowlist', 'none']
+};
+
+// The words people reach for, mapped to the ones the protocol uses. "on" and
+// "off" are the obvious things to type for read receipts and mean nothing on
+// the wire, which is exactly the mistake worth absorbing.
+const PRIVACY_VALUE_ALIASES = {
+  everyone:            'all',
+  my_contacts:         'contacts',
+  contacts_except:     'contact_blacklist',
+  contact_whitelist:   'contact_allowlist',
+  nobody:              'none',
+  off:                 'none',
+  on:                  'all',
+  same_as_last_seen:   'match_last_seen',
+  last_seen:           'match_last_seen',
+  standard:            'on_standard'
+};
+
+// Where a word means something different for one setting than for the rest.
+// "on" is "all" everywhere except defense, whose on-state has its own name.
+const PRIVACY_VALUE_ALIASES_BY_NAME = {
+  defense: { on: 'on_standard' },
+  online:  { on: 'all', off: 'match_last_seen' }
+};
+
 // Wire name → the key it is reported under in the settings object.
 const PRIVACY_WIRE_TO_KEY = {
   last:         'lastSeen',
@@ -4287,19 +4328,45 @@ class WhalibmobClient extends EventEmitter {
 
   // Change profile picture
   // buf: Buffer with JPEG image data
+  // Change your own profile picture.
+  //
+  // buf: a Buffer of JPEG bytes, or null to remove the current picture.
+  // Returns the new picture id, or 'remove' when it was taken down.
+  //
+  // The picture is not addressed by sending the IQ *to* yourself: it goes to
+  // the server with the account named in `target`, the same shape a group
+  // picture uses. Addressed the other way the server files it nowhere and never
+  // answers, which looked from the outside like the picture had been set — the
+  // stanza went out, nothing came back, and nothing checked.
   async changeProfilePicture(buf) {
     if (!this._store) throw new Error('Not connected');
-    const selfJid = `${this._store.phoneNumber}@s.whatsapp.net`;
-    const id = this._genMsgId();
+    const selfJid = this._ownDeviceJid
+      ? toNonAdJid(this._ownDeviceJid())
+      : `${this._store.phoneNumber}@s.whatsapp.net`;
+
     const node = new BinaryNode('iq', {
-      id,
-      xmlns: 'w:profile:picture',
-      to:    selfJid,
-      type:  'set'
-    }, [
-      new BinaryNode('picture', { type: 'image' }, buf)
-    ]);
-    return this._sendIq(node);
+      id:     this._genMsgId(),
+      xmlns:  'w:profile:picture',
+      to:     's.whatsapp.net',
+      target: jidStrToObj(selfJid),
+      type:   'set'
+    }, buf ? [new BinaryNode('picture', { type: 'image' }, buf)] : null);
+
+    const resp = await this._sendIq(node);
+    if (!resp) throw new Error('changeProfilePicture: no reply from server (IQ timed out)');
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('changeProfilePicture: ' +
+        (String(code) === '406' ? 'the image was rejected (must be a JPEG)'
+       : String(code) === '401' ? 'not authorised to change this picture'
+       : 'server rejected the request' + (code ? ' (' + code + ')' : '')));
+    }
+
+    if (!buf) return 'remove';
+    const picNode = findChild(resp, 'picture');
+    return (picNode && picNode.attrs && picNode.attrs.id)
+      ? String(picNode.attrs.id) : null;
   }
 
   // ─── Privacy settings ─────────────────────────────────────────────────────
@@ -4372,6 +4439,8 @@ class WhalibmobClient extends EventEmitter {
         Object.keys(PRIVACY_NAME_ALIASES).join(', '));
     }
 
+    const wireValue = this._privacyWireValue(name, value);
+
     // 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.
@@ -4389,7 +4458,7 @@ class WhalibmobClient extends EventEmitter {
       type:  'set'
     }, [
       new BinaryNode('privacy', {}, [
-        new BinaryNode('category', { name, value: String(value) },
+        new BinaryNode('category', { name, value: wireValue },
           children.length > 0 ? children : null)
       ])
     ]);
@@ -4400,7 +4469,7 @@ class WhalibmobClient extends EventEmitter {
       const errNode = findChild(resp, 'error');
       const code    = errNode && errNode.attrs && errNode.attrs.code;
       const text    = errNode && errNode.attrs && errNode.attrs.text;
-      throw new Error('changePrivacySetting: server rejected ' + name + '=' + value +
+      throw new Error('changePrivacySetting: server rejected ' + name + '=' + wireValue +
         (code ? ' (' + code + (text ? ' ' + text : '') + ')' : ''));
     }
 
@@ -4408,10 +4477,31 @@ class WhalibmobClient extends EventEmitter {
     // rather than making the caller re-query.
     const key = PRIVACY_WIRE_TO_KEY[name];
     this._privacySettings = Object.assign({}, this._privacySettings || {},
-      { [key]: String(value) });
+      { [key]: wireValue });
     return this._privacySettings;
   }
 
+  // Resolve what the caller typed to what this particular setting accepts.
+  //
+  // The allowed set differs per setting — read receipts are all-or-none, online
+  // is all-or-match-last-seen — so "contacts" is right for one and meaningless
+  // for another. Sending a meaningless one gets no reply at all.
+  _privacyWireValue(name, value) {
+    const allowed = PRIVACY_ALLOWED_VALUES[name];
+    const raw     = String(value == null ? '' : value).trim().toLowerCase();
+    const perName = PRIVACY_VALUE_ALIASES_BY_NAME[name] || {};
+    const mapped  = allowed && allowed.includes(raw)
+      ? raw
+      : (perName[raw] || PRIVACY_VALUE_ALIASES[raw] || raw);
+
+    if (allowed && !allowed.includes(mapped)) {
+      throw new Error('changePrivacySetting: "' + value + '" is not a value ' +
+        name + ' accepts — use one of ' + allowed.join(', ') +
+        '. The server ignores anything else without answering.');
+    }
+    return mapped;
+  }
+
   // ──────────────────────────────────────────────────────────────────────────
   // MESSAGING — editMessage, deleteMessage, sendStatus, forwardMessage
   // ──────────────────────────────────────────────────────────────────────────
@@ -4900,8 +4990,26 @@ class WhalibmobClient extends EventEmitter {
   async fetchReachoutTimelock() {
     const payload = await this._mexQuery(MEX_QUERY_REACHOUT_TIMELOCK, {},
       'xwa2_fetch_account_reachout_timelock');
+
+    // Some servers answer this one tersely: a bare boolean rather than the
+    // object with the expiry in it. `false` is a definite "no restriction" and
+    // is taken at face value; `true` says there is one but not when it ends, so
+    // it is marked as an expiry we do not know and the announcement supplies
+    // the countdown.
+    if (typeof payload === 'boolean') {
+      return this._setReachoutTimelock(
+        ReachoutTimelock.parseTimelockPayload({ is_active: payload }), 'query');
+    }
+
+    if (payload == null || typeof payload !== 'object') {
+      const err = new Error('the server answered ' + JSON.stringify(payload) +
+        ', which says nothing about a restriction either way');
+      err.mexDecoded = payload;
+      throw err;
+    }
+
     return this._setReachoutTimelock(
-      ReachoutTimelock.parseTimelockPayload(payload || {}), 'query');
+      ReachoutTimelock.parseTimelockPayload(payload), 'query');
   }
 
   /**
@@ -4999,15 +5107,50 @@ class WhalibmobClient extends EventEmitter {
       return dataPath ? (json.data && json.data[dataPath]) : json.data;
     }
 
-    // The query itself worked — this is purely about how the answer was
-    // encoded, and saying so is the difference between a fixable report and a
-    // shrug.
+    // Not JSON, so the other encoding this transport uses: Argo, which is what
+    // newer servers answer with. It carries its own field names, so it decodes
+    // without the GraphQL schema the query was written against.
     const resultNode = findChildDeep(resp, 'result');
     const format     = resultNode && resultNode.attrs && resultNode.attrs.format;
+    const raw        = resultNode ? getNodeContent(resultNode) : null;
+
+    // Only when the server said so. Guessing that unlabelled bytes are Argo
+    // turns "this reply is not what I expected" into a misleading complaint
+    // about a format that was never claimed.
+    if (raw && raw.length && format && String(format).toLowerCase() === 'argo') {
+      let decoded;
+      try {
+        decoded = decodeArgo(raw);
+      } catch (e) {
+        const err = new Error('mex query ' + queryId + ': the reply is ' +
+          (format ? '"' + format + '"' : 'binary') + ' and could not be decoded — ' +
+          e.message + ' (' + raw.length + ' bytes: ' + raw.toString('hex') + ')');
+        err.mexFormat  = format ? String(format) : null;
+        err.mexPayload = raw;
+        throw err;
+      }
+      _whaDbg('[DBG] MEX_ARGO decoded ' + JSON.stringify(decoded));
+
+      if (decoded && typeof decoded === 'object') {
+        if (decoded.errors && decoded.errors.length) {
+          throw new Error('mex query ' + queryId + ': ' +
+            decoded.errors.map(e => (e && e.message) || 'unknown error').join(', '));
+        }
+        if (decoded.data !== undefined) {
+          return dataPath ? (decoded.data && decoded.data[dataPath]) : decoded.data;
+        }
+        return dataPath ? decoded[dataPath] : decoded;
+      }
+
+      // Not a GraphQL envelope but still an answer — a bare boolean, most
+      // often. Handed back as-is for the caller to interpret, since only the
+      // caller knows what its own query means.
+      return decoded;
+    }
+
     if (format && String(format).toLowerCase() !== 'json') {
-      const raw = getNodeContent(resultNode);
       const err = new Error('mex query ' + queryId + ': the server answered in "' +
-        format + '" rather than JSON, which this library cannot read' +
+        format + '", which this library cannot read' +
         (raw ? ' (' + raw.length + ' bytes: ' + raw.toString('hex') + ')' : ''));
       err.mexFormat  = String(format);
       err.mexPayload = raw || null;
@@ -5080,13 +5223,27 @@ class WhalibmobClient extends EventEmitter {
   }
 
   // Internal: parse newsletter response from w:mex IQ result
+  //
+  // Every newsletter call travels the same transport as the restriction query,
+  // so a server that answers that one in Argo answers these in Argo too. This
+  // used to swallow that and return null, which reads as "no such newsletter"
+  // rather than "this reply is in an encoding nothing here can read" — the
+  // difference between a shrug and something a caller can act on.
   _parseNewsletterResponse(resp) {
     try {
-      const resultNode = findChild(resp, 'result');
-      if (!resultNode) return null;
-      const buf = getNodeContent(resultNode);
-      if (!buf) return null;
-      const json = JSON.parse(buf.toString('utf8'));
+      const json = this._mexJsonFrom(resp);
+      if (!json) {
+        const resultNode = findChildDeep(resp, 'result');
+        const format     = resultNode && resultNode.attrs && resultNode.attrs.format;
+        if (format && String(format).toLowerCase() !== 'json') {
+          _whaDbg('[DBG] NEWSLETTER reply format=' + format + ' — cannot decode');
+          const err = new Error('the server answered in "' + format +
+            '" rather than JSON, which this library cannot read');
+          err.mexFormat = String(format);
+          throw err;
+        }
+        return null;
+      }
       const nl = json && (json.newsletter || (json.data && json.data.xwa2_newsletter));
       if (!nl) return null;
       const meta = nl.metadata || nl;
@@ -5097,7 +5254,8 @@ class WhalibmobClient extends EventEmitter {
         subscriberCount: nl.subscribers_count || meta.subscriber_count || 0,
         creationTime:    nl.creation_time || meta.creation_time || 0
       };
-    } catch (_) {
+    } catch (err) {
+      if (err && err.mexFormat) throw err;
       return null;
     }
   }

package/lib/argo/ArgoDecoder.js

@@ -0,0 +1,240 @@
+'use strict';
+
+// Argo — the binary encoding WhatsApp's GraphQL transport answers in.
+//
+// A w:mex reply can come back as JSON or as Argo; the <result> node says which.
+// Argo is normally decoded against the schema of the query that asked, which a
+// client outside Meta does not have. But a message can set a SelfDescribing
+// flag, and then it carries its own field names and types — which is what
+// WhatsApp sends, and what makes this readable at all.
+//
+// Only the self-describing form is implemented. A schema-typed message is
+// refused rather than guessed at.
+//
+// Layout:
+//   [header bitset][block][block]…[core]
+// where each block is a length label followed by that many bytes, and the core
+// is the last one. Values in the core are Labels — zigzag ULEB128 integers —
+// that either carry a small value outright or point into a block.
+
+// ─── labels ──────────────────────────────────────────────────────────────────
+//
+// A label is one signed integer doing several jobs at once. Non-negative is a
+// length or a boolean; the three values below are markers; anything lower is a
+// backreference to a value already seen.
+const LABEL_NULL   = -1;
+const LABEL_ABSENT = -2;
+const LABEL_ERROR  = -3;
+// -4 is the first backreference and means "the first value in this block".
+const BACKREF_BASE = -4;
+
+// Self-describing type markers, as label values.
+const MARKER = {
+  NULL:   -1,
+  FALSE:   0,
+  TRUE:    1,
+  OBJECT:  2,
+  LIST:    3,
+  STRING:  4,
+  BYTES:   5,
+  INT:     6,
+  FLOAT:   7
+};
+
+// Header flag bit positions.
+const FLAG_INLINE_EVERYTHING = 0;
+const FLAG_SELF_DESCRIBING   = 1;
+
+class Reader {
+  constructor(buf) {
+    this.buf = buf;
+    this.pos = 0;
+  }
+  get done()      { return this.pos >= this.buf.length; }
+  byte() {
+    if (this.pos >= this.buf.length) throw new Error('argo: ran off the end of the message');
+    return this.buf[this.pos++];
+  }
+  peek()          { return this.buf[this.pos]; }
+  take(n) {
+    if (n < 0 || this.pos + n > this.buf.length) {
+      throw new Error('argo: asked for ' + n + ' bytes with ' +
+        (this.buf.length - this.pos) + ' left');
+    }
+    const out = this.buf.slice(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  // ULEB128, then zigzag back to signed.
+  label() {
+    let value = 0n, shift = 0n;
+    for (;;) {
+      const b = this.byte();
+      value |= BigInt(b & 0x7f) << shift;
+      if (!(b & 0x80)) break;
+      shift += 7n;
+      if (shift > 63n) throw new Error('argo: label is too long to be a number');
+    }
+    const signed = (value >> 1n) ^ -(value & 1n);
+    return Number(signed);
+  }
+}
+
+function readHeader(reader) {
+  let bits = 0, shift = 0, more = true;
+  while (more) {
+    const b = reader.byte();
+    bits |= (b >> 1) << shift;
+    shift += 7;
+    more = (b & 1) === 1;
+  }
+  return {
+    bits,
+    selfDescribing:   !!(bits >> FLAG_SELF_DESCRIBING   & 1),
+    inlineEverything: !!(bits >> FLAG_INLINE_EVERYTHING & 1)
+  };
+}
+
+// A block holds the bulky values — strings, byte arrays, numbers — with the
+// core referring to them in order. Blocks are handed out in the order their
+// types are first needed, which is why they are taken from a queue rather than
+// looked up by name.
+class BlockQueue {
+  constructor(blocks, core, inlineEverything) {
+    this.blocks = blocks;
+    this.core   = core;
+    this.inline = inlineEverything;
+    this.next   = 0;
+    this.byKey  = new Map();
+  }
+  for(key) {
+    if (this.inline) return { reader: this.core, seen: [] };
+    if (!this.byKey.has(key)) {
+      const buf = this.blocks[this.next++];
+      if (buf === undefined) throw new Error('argo: message is missing a block for ' + key);
+      this.byKey.set(key, { reader: new Reader(buf), seen: [] });
+    }
+    return this.byKey.get(key);
+  }
+}
+
+function decodeArgo(bytes) {
+  const buf    = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+  const reader = new Reader(buf);
+  const header = readHeader(reader);
+
+  if (!header.selfDescribing) {
+    const err = new Error('argo: this message is encoded against a GraphQL schema ' +
+      'rather than describing itself, so it cannot be read without that schema');
+    err.needsSchema = true;
+    throw err;
+  }
+
+  const blocks = [];
+  if (header.inlineEverything) {
+    blocks.push(reader.take(buf.length - reader.pos));
+  } else {
+    while (!reader.done) {
+      const len = reader.label();
+      if (len < 0) throw new Error('argo: block length cannot be ' + len);
+      blocks.push(reader.take(len));
+    }
+  }
+  if (!blocks.length) throw new Error('argo: message has no core');
+
+  // The core is the last block, and every other block feeds it.
+  const core   = new Reader(blocks[blocks.length - 1]);
+  const queue  = new BlockQueue(blocks.slice(0, -1), core, header.inlineEverything);
+
+  return readValue(core, queue);
+}
+
+// One length-prefixed value out of a block, with backreferences resolved.
+//
+// The same string written twice is written once and pointed at the second time,
+// which is most of why this format is small. A backreference that points at
+// nothing means the message and our reading of it have diverged.
+function readBlockValue(core, queue, key, convert) {
+  const block = queue.for(key);
+  const label = core.label();
+  if (label <= BACKREF_BASE) {
+    const idx = -label + BACKREF_BASE;
+    if (idx < 0 || idx >= block.seen.length) {
+      throw new Error('argo: backreference ' + label + ' points outside ' + key);
+    }
+    return block.seen[idx];
+  }
+  if (label < 0) throw new Error('argo: ' + key + ' cannot have label ' + label);
+  const value = convert(block.reader.take(label));
+  block.seen.push(value);
+  return value;
+}
+
+function readValue(core, queue) {
+  const marker = core.label();
+
+  switch (marker) {
+    case MARKER.NULL:   return null;
+    case MARKER.FALSE:  return false;
+    case MARKER.TRUE:   return true;
+
+    case MARKER.OBJECT: {
+      const count = core.label();
+      if (count < 0) throw new Error('argo: object cannot have ' + count + ' fields');
+      const out = {};
+      for (let i = 0; i < count; i++) {
+        const name = readBlockValue(core, queue, 'String', b => b.toString('utf8'));
+        out[name]  = readValue(core, queue);
+      }
+      return out;
+    }
+
+    case MARKER.LIST: {
+      const count = core.label();
+      if (count < 0) throw new Error('argo: list cannot have ' + count + ' items');
+      const out = [];
+      for (let i = 0; i < count; i++) out.push(readValue(core, queue));
+      return out;
+    }
+
+    case MARKER.STRING: return readBlockValue(core, queue, 'String', b => b.toString('utf8'));
+    case MARKER.BYTES:  return readBlockValue(core, queue, 'Bytes',  b => Buffer.from(b));
+
+    // An integer lives entirely in its block — the core spends nothing on it.
+    case MARKER.INT: {
+      const block = queue.for('Varint');
+      return block.reader.label();
+    }
+
+    case MARKER.FLOAT: {
+      const block = queue.for('Float');
+      return block.reader.take(8).readDoubleLE(0);
+    }
+
+    default:
+      if (marker === LABEL_ABSENT) return undefined;
+      if (marker === LABEL_ERROR)  return readValue(core, queue);
+      throw new Error('argo: unknown type marker ' + marker);
+  }
+}
+
+/**
+ * Decode an Argo message, or return null when it is not one this can read.
+ *
+ * Never throws: a caller reaching for this already has a reply it could not
+ * parse, and a second failure on top of that is not news. `decodeArgo` is there
+ * for when the reason matters.
+ */
+function tryDecodeArgo(bytes) {
+  try { return decodeArgo(bytes); }
+  catch (_) { return null; }
+}
+
+module.exports = {
+  decodeArgo,
+  tryDecodeArgo,
+  MARKER,
+  LABEL_NULL,
+  LABEL_ABSENT,
+  LABEL_ERROR
+};

package/package.json

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