whalibmob 5.29.2 → 5.29.4

package/lib/Client.js

@@ -1898,8 +1898,18 @@ class WhalibmobClient extends EventEmitter {
     const dirtyTypes = [];
     for (const child of children) {
       if (!child || child.description !== 'dirty') continue;
-      const type = child.attrs && child.attrs.type;
-      if (type) dirtyTypes.push(type);
+      const attrs = child.attrs || {};
+      if (!attrs.type) continue;
+      // The announcement carries the moment the change happened, and clearing
+      // the bit means naming that moment back. A <clean> without it does not
+      // acknowledge anything in particular, so the server keeps announcing the
+      // same change on every connection from now on — which is what it did:
+      // the timestamp was on the wire and never read off it. whatsmeow's
+      // MarkNotDirty takes it as an argument for exactly this reason.
+      dirtyTypes.push({
+        type:      String(attrs.type),
+        timestamp: attrs.timestamp ? String(attrs.timestamp) : null
+      });
     }
 
     if (dirtyTypes.length > 0) {
@@ -1922,15 +1932,23 @@ class WhalibmobClient extends EventEmitter {
   /**
    * Acknowledge a dirty bit so the server stops announcing it.
    *
-   * `<ib><dirty type="..."/></ib>` is the server saying something changed while
-   * we were away. Whatever the client does about it, the bit has to be cleared
-   * or the same announcement arrives on every connection.
+   * `<ib><dirty type="..." timestamp="..."/></ib>` is the server saying
+   * something changed while we were away, and when. Whatever the client does
+   * about it, the bit has to be cleared or the same announcement arrives on
+   * every connection.
+   *
+   * The timestamp is half of that acknowledgement: it says *which* change is
+   * being cleared. Every `<clean>` this sent went out without one, because the
+   * attribute was never read off the `<dirty>` that carried it — so nothing was
+   * acknowledged in particular and the server kept announcing. whatsmeow's
+   * MarkNotDirty takes it as an argument for the same reason.
    *
    * @param {string} type            the dirty type, e.g. 'groups'
    * @param {number|string} [fromTs] the timestamp the announcement carried
+   * @returns {boolean} whether the acknowledgement went out
    */
-  _cleanDirtyBits(type, fromTs) {
-    if (!this._socket || !this._connected) return;
+  markNotDirty(type, fromTs) {
+    if (!this._socket || !this._connected) return false;
     const attrs = { type: String(type) };
     if (fromTs) attrs.timestamp = String(fromTs);
     _whaDbg('[DBG] CLEAN_DIRTY type=' + type + (fromTs ? ' t=' + fromTs : ''));
@@ -1940,6 +1958,7 @@ class WhalibmobClient extends EventEmitter {
       type:  'set',
       xmlns: 'urn:xmpp:whatsapp:dirty'
     }, [new BinaryNode('clean', attrs, null)]));
+    return true;
   }
 
   /**
@@ -1948,7 +1967,7 @@ class WhalibmobClient extends EventEmitter {
    * Best effort on purpose: the bit has to be cleared either way, or the server
    * announces the same change on every connection from now on.
    */
-  _refreshGroupsAfterDirty(type) {
+  _refreshGroupsAfterDirty(type, fromTs) {
     Promise.resolve()
       .then(() => this.fetchAllGroups())
       .then(groups => {
@@ -1957,7 +1976,7 @@ class WhalibmobClient extends EventEmitter {
       .catch(err => {
         _whaDbg('[DBG] DIRTY groups — refresh failed: ' + (err && err.message));
       })
-      .then(() => this._cleanDirtyBits(type));
+      .then(() => this.markNotDirty(type, fromTs));
   }
 
   _sendAppStateSyncForTypes(dirtyTypes) {
@@ -1974,8 +1993,10 @@ class WhalibmobClient extends EventEmitter {
       regular:              ['regular']
     };
 
+    // Each entry is { type, timestamp } — the timestamp is what the
+    // announcement said, and it goes back on the <clean> that acknowledges it.
     const collections = new Set();
-    for (const type of dirtyTypes) {
+    for (const { type, timestamp } of dirtyTypes) {
       const mapped = COLLECTION_MAP[type];
       if (!mapped) {
         if (type === 'groups') {
@@ -1983,14 +2004,14 @@ class WhalibmobClient extends EventEmitter {
           // away. Clearing it without looking leaves every cached group sitting
           // on the membership and settings it had before we disconnected, so
           // re-read them first and acknowledge after.
-          this._refreshGroupsAfterDirty(type);
+          this._refreshGroupsAfterDirty(type, timestamp);
           continue;
         }
         // Not an app-state collection, but still a dirty bit the server expects
         // to be cleared. Ignoring it meant the server re-announced it on every
         // single connection, forever.
         _whaDbg('[DBG] DIRTY type=' + type + ' — not an app-state collection, clearing the bit');
-        this._cleanDirtyBits(type);
+        this.markNotDirty(type, timestamp);
         continue;
       }
       for (const c of mapped) collections.add(c);
@@ -2003,8 +2024,8 @@ class WhalibmobClient extends EventEmitter {
     // 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);
+      for (const { type, timestamp } of dirtyTypes) {
+        if (COLLECTION_MAP[type]) this.markNotDirty(type, timestamp);
       }
     };
 
@@ -3960,26 +3981,28 @@ class WhalibmobClient extends EventEmitter {
       // hash, and if it matches there is nothing to invalidate and nothing to
       // ask usync about — see DeviceManager.verifyDeviceDelta().
       if (fromUser && this._devMgr) {
-        const delta = this._parseDeviceDelta(node);
-        if (delta) {
+        const steps = this._parseDeviceDelta(node);
+        if (steps) {
           // The primary half is keyed the way the notification is addressed.
-          const priKey    = isLid ? 'lid:' + fromUser : fromUser;
-          const priServer = isLid ? 'lid' : 's.whatsapp.net';
-          const priOk     = this._devMgr.verifyDeviceDelta(
-            priKey, fromUser, delta.changes, delta.hash, priServer);
-
           // The secondary half only exists when the notification arrived under
           // the number and named the LID alongside it.
-          if (!isLid && lidUser && delta.lidHash && delta.lidChanges) {
-            const lidOk = this._devMgr.verifyDeviceDelta(
-              'lid:' + lidUser, lidUser, delta.lidChanges, delta.lidHash, 'lid');
+          const { primaryOk, lidOk } = this._devMgr.applyDeviceDelta({
+            priKey:    isLid ? 'lid:' + fromUser : fromUser,
+            priUser:   fromUser,
+            priServer: isLid ? 'lid' : 's.whatsapp.net',
+            lidKey:    (!isLid && lidUser) ? 'lid:' + lidUser : null,
+            lidUser:   (!isLid && lidUser) ? lidUser : null,
+            steps
+          });
+
+          if (!isLid && lidUser) {
             _whaDbg('[DBG] NOTIF_DEVICES lid delta ' +
               (lidOk ? 'verified' : 'unverified') + ' for lid:' + lidUser);
           }
 
-          if (priOk) {
-            _whaDbg('[DBG] NOTIF_DEVICES delta verified for ' + priKey +
-              ' — cache kept, no usync needed');
+          if (primaryOk) {
+            _whaDbg('[DBG] NOTIF_DEVICES delta verified over ' + steps.length +
+              ' step(s) — cache kept, no usync needed');
             return;
           }
         }
@@ -4037,39 +4060,44 @@ class WhalibmobClient extends EventEmitter {
   }
 
   /**
-   * Read a `devices` notification as a change plus the hash it should produce.
+   * Read a `devices` notification as an ordered list of steps.
    *
    *   <notification type="devices" from="…">
    *     <add device_hash="2:…"><device jid="40711111111:3@s.whatsapp.net"/></add>
+   *     <add device_hash="2:…"><device jid="40711111111:4@s.whatsapp.net"/></add>
    *   </notification>
    *
-   * Children are `add`, `remove`, or `update`. Only the first two say something
-   * that can be applied; `update` does not name what it changed, so it is
-   * treated as unreadable here and the caller falls back to invalidating.
+   * Each child is one change, and the `device_hash` on it is the hash of the
+   * device list **after that change** — not of the notification as a whole. So
+   * children in a multi-change notification carry different hashes, by design,
+   * and each has to be checked against the list as it stands at that point.
+   *
+   * This used to demand that every child agree on one hash and give up when
+   * they did not, which is exactly what a two-change notification looks like:
+   * someone linking a laptop and a tablet in the same sitting produced two
+   * children, two hashes, and the whole thing was thrown away — cache dropped,
+   * full usync round-trip on the next send. Steps are now kept separately and
+   * applied one at a time, the way whatsmeow's handleDeviceNotification does.
    *
-   * All children must agree on the hash — the server sends one per child, and a
-   * notification carrying two different ones is describing intermediate states
-   * this cannot reconstruct.
+   * Children are `add`, `remove`, or `update`. `update` does not name what it
+   * changed, so it survives as a step that tells the applier to drop the cache
+   * and carry on with the rest. A tag this does not know is skipped, and a
+   * child that cannot be read at all rejects the notification: guessing at a
+   * change we could not parse is how a device list quietly goes wrong.
    *
-   * Each child may also carry `device_lid_hash`, and each `<device>` a `lid`
-   * beside its `jid`, describing the same change to the contact's LID device
-   * list. That half is optional: missing on any child, and only the phone-number
-   * half is returned, which is what the caller then verifies. It is never a
-   * reason to reject the notification outright — the two lists are hashed
-   * independently by the server and are checked independently here.
+   * Each child may also carry `device_lid_hash`, and its `<device>` a `lid`
+   * beside the `jid`, describing the same change to the contact's LID device
+   * list. That half is per-step and optional — a step without it leaves the LID
+   * list alone rather than invalidating the step, because the server hashes the
+   * two lists independently and they are checked independently here.
    *
-   * @returns {{changes: Array<{tag, deviceId}>, hash: string,
-   *            lidChanges: Array<{tag, deviceId}>|null, lidHash: string|null}|null}
+   * @returns {Array<{tag: 'add'|'remove'|'update', deviceId: number|null,
+   *                  hash: string|null, lidDeviceId: number|null,
+   *                  lidHash: string|null}>|null}
    */
   _parseDeviceDelta(node) {
     if (!node || !Array.isArray(node.content)) return null;
 
-    const changes    = [];
-    const lidChanges = [];
-    let hash    = null;
-    let lidHash = null;
-    let lidOk   = true;   // every child so far carried a usable LID half
-
     // "user:3@server" / "user@server" → 3 / 0, or null when unreadable.
     const deviceIdOf = (jid) => {
       if (!jid) return null;
@@ -4080,40 +4108,43 @@ class WhalibmobClient extends EventEmitter {
       return Number.isFinite(device) ? device : null;
     };
 
+    const steps = [];
+
     for (const child of node.content) {
       if (!child || !child.description) continue;
       const tag = child.description;
-      if (tag !== 'add' && tag !== 'remove') return null;   // 'update' and friends
 
-      const childHash = child.attrs && child.attrs.device_hash;
-      if (!childHash) return null;
-      if (hash === null) hash = String(childHash);
-      else if (hash !== String(childHash)) return null;     // disagreeing children
+      if (tag === 'update') {
+        steps.push({ tag, deviceId: null, hash: null, lidDeviceId: null, lidHash: null });
+        continue;
+      }
+      if (tag !== 'add' && tag !== 'remove') continue;   // not ours to interpret
+
+      const attrs = child.attrs || {};
+      const hash  = attrs.device_hash ? String(attrs.device_hash) : null;
+      if (!hash) return null;
 
       const deviceNode = findChild(child, 'device');
-      const attrs      = (deviceNode && deviceNode.attrs) || {};
-      const device     = deviceIdOf(attrs.jid);
-      if (device === null) return null;
-      changes.push({ tag, deviceId: device });
-
-      // LID half — optional, and giving up on it costs the number half nothing.
-      if (!lidOk) continue;
-      const childLidHash = child.attrs.device_lid_hash;
-      const lidDevice    = deviceIdOf(attrs.lid);
-      if (!childLidHash || lidDevice === null) { lidOk = false; continue; }
-      if (lidHash === null) lidHash = String(childLidHash);
-      else if (lidHash !== String(childLidHash)) { lidOk = false; continue; }
-      lidChanges.push({ tag, deviceId: lidDevice });
-    }
-
-    if (!changes.length || !hash) return null;
-    const haveLid = lidOk && lidHash && lidChanges.length === changes.length;
-    return {
-      changes,
-      hash,
-      lidChanges: haveLid ? lidChanges : null,
-      lidHash:    haveLid ? lidHash    : null
-    };
+      const dattrs     = (deviceNode && deviceNode.attrs) || {};
+      const deviceId   = deviceIdOf(dattrs.jid);
+      if (deviceId === null) return null;
+
+      // Both halves of the LID pair or neither: a hash with no device to apply
+      // it to, or a device with no hash to check it against, is not a step.
+      const lidHash     = attrs.device_lid_hash ? String(attrs.device_lid_hash) : null;
+      const lidDeviceId = deviceIdOf(dattrs.lid);
+      const haveLid     = !!lidHash && lidDeviceId !== null;
+
+      steps.push({
+        tag,
+        deviceId,
+        hash,
+        lidDeviceId: haveLid ? lidDeviceId : null,
+        lidHash:     haveLid ? lidHash     : null
+      });
+    }
+
+    return steps.length ? steps : null;
   }
 
   _processDeviceUpdate(devicesNode) {
@@ -6285,9 +6316,59 @@ class WhalibmobClient extends EventEmitter {
     const keyName = getMediaKeyName(KEY_NAME[d.type] || d.type);
     if (!keyName) throw new Error('downloadMedia: unsupported media type "' + d.type + '"');
 
+    // Both digests go down by default. The message says what the file should
+    // be; there is no reason to take the CDN's word for it. `verify: false`
+    // turns them off for a caller that wants the bytes whatever they are — the
+    // MAC is checked either way, and that is the one that authenticates.
     return downloadMedia(url, d.mediaKey, keyName, {
       web:           this._mode === 'web',
-      fileEncSha256: opts.verify ? d.fileEncSha256 : undefined
+      verify:        opts.verify !== false,
+      fileEncSha256: d.fileEncSha256,
+      fileSha256:    d.fileSha256
+    });
+  }
+
+  /**
+   * Download the preview image of a message that quoted a link.
+   *
+   * A link preview's thumbnail is a media file in its own right — its own
+   * directPath, its own mediaKey, its own digests — carried beside the text
+   * rather than inside it, and encrypted under a key name of its own. So
+   * `downloadMedia` cannot fetch it: that reads the message's own media, and a
+   * text message has none. This is whatsmeow's DownloadThumbnail.
+   *
+   * The small inline preview is a different thing and needs no download: it is
+   * already on the decoded message as `jpegThumbnail`.
+   *
+   * @param {object} decoded  a decoded message, or the `message` event payload
+   * @param {object} [opts]   `verify: false` to skip the digest checks
+   * @returns {Promise<Buffer>} the full-size preview image
+   */
+  async downloadThumbnail(decoded, opts) {
+    opts = opts || {};
+    const d = (decoded && decoded.decoded) ? decoded.decoded : decoded;
+    if (!d) throw new Error('downloadThumbnail: a decoded message is required');
+
+    const thumb = d.thumbnail;
+    if (!thumb || !thumb.mediaKey) {
+      throw new Error('downloadThumbnail: this message carries no downloadable ' +
+        'thumbnail (a link preview without one, or not a link at all)');
+    }
+
+    const { downloadMedia, getThumbnailKeyName, resolveMediaUrl } =
+      require('./MediaService');
+    const keyName = getThumbnailKeyName(d.type === 'text' ? 'text' : d.type);
+    if (!keyName) {
+      throw new Error('downloadThumbnail: no thumbnail key name for "' + d.type + '"');
+    }
+    const url = resolveMediaUrl(null, thumb.directPath);
+    if (!url) throw new Error('downloadThumbnail: the thumbnail has no CDN location');
+
+    return downloadMedia(url, thumb.mediaKey, keyName, {
+      web:           this._mode === 'web',
+      verify:        opts.verify !== false,
+      fileEncSha256: thumb.thumbnailEncSha256,
+      fileSha256:    thumb.thumbnailSha256
     });
   }
 
@@ -7290,6 +7371,169 @@ class WhalibmobClient extends EventEmitter {
     return this._sender.sendPoll(to, question, options, selectableCount, opts);
   }
 
+  /**
+   * Read a vote on a poll.
+   *
+   * A vote arrives as its own message and the ballot inside it is encrypted, so
+   * nothing about who voted for what is visible in the stanza. The key is
+   * derived from the poll's message secret — the `encKey` `sendPoll` returned,
+   * or `decoded.encKey` on a poll somebody else sent us:
+   *
+   *   key = HKDF-SHA256(secret, salt = ∅,
+   *                     info = pollId ‖ pollSender ‖ voter ‖ "Poll Vote", 32)
+   *   AAD = pollId ‖ 0x00 ‖ voter
+   *   ballot = AES-256-GCM-open(key, encIv, encPayload, AAD)
+   *
+   * The ballot names the chosen options by SHA-256 of their text, not by index
+   * or by name, so pass `options` — the poll's option strings, in any order —
+   * and the choices come back as text. Without them you get the hashes and can
+   * match them yourself.
+   *
+   * Both JIDs are taken without their device: a vote belongs to an account.
+   *
+   * This is whatsmeow's DecryptPollVote. Nothing here could read a vote before:
+   * `sendPoll` handed back the key and left the rest to the caller.
+   *
+   * @param {object} vote            the `message` event payload, or its `decoded`
+   * @param {object} opts
+   * @param {Buffer} opts.encKey     the poll's message secret (aka messageSecret)
+   * @param {string} [opts.voter]    who voted; defaults to the message's sender
+   * @param {string} [opts.pollSender] who sent the poll; defaults to the key's
+   *                                 remoteJid, or to the voter when the poll is
+   *                                 ours
+   * @param {string[]} [opts.options] the poll's options, to name the choices
+   * @returns {{selected: string[], selectedHashes: Buffer[], votedAt: number|null}}
+   */
+  decryptPollVote(vote, opts) {
+    opts = opts || {};
+    const d = (vote && vote.decoded) ? vote.decoded : vote;
+    if (!d || d.type !== 'pollVote') {
+      throw new Error('decryptPollVote: this is not a vote on a poll');
+    }
+    if (!d.encPayload || !d.encIv) {
+      throw new Error('decryptPollVote: the vote carries no encrypted ballot');
+    }
+    const secret = opts.encKey || opts.messageSecret;
+    if (!secret || secret.length !== 32) {
+      throw new Error('decryptPollVote: the poll\'s 32-byte encKey is required — ' +
+        'it is what sendPoll returned, or decoded.encKey on a poll we received');
+    }
+
+    const key    = d.pollKey || {};
+    const pollId = String(key.id || '');
+    if (!pollId) throw new Error('decryptPollVote: the vote does not name a poll');
+
+    // Who voted, and who the poll belongs to. `fromMe` on the key means the
+    // poll and the vote came from the same account, which is the one case the
+    // key's remoteJid names the chat rather than the poll's author.
+    const voter = toNonAdJid(String(
+      opts.voter || (vote && vote.participant) || (vote && vote.from) || ''));
+    if (!voter || voter.startsWith('@')) {
+      throw new Error('decryptPollVote: cannot tell who cast this vote — pass opts.voter');
+    }
+    const pollSender = toNonAdJid(String(
+      opts.pollSender || (key.fromMe ? voter : (key.remoteJid || voter))));
+
+    const info = Buffer.concat([
+      Buffer.from(pollId, 'utf8'),
+      Buffer.from(pollSender, 'utf8'),
+      Buffer.from(voter, 'utf8'),
+      Buffer.from('Poll Vote', 'utf8')
+    ]);
+    const { hkdfSha256 } = require('./hkdf');
+    const voteKey = hkdfSha256(Buffer.from(secret), Buffer.alloc(0), info, 32);
+
+    const aad = Buffer.concat([
+      Buffer.from(pollId, 'utf8'), Buffer.from([0]), Buffer.from(voter, 'utf8')
+    ]);
+
+    // GCM's tag is the last 16 bytes of the payload, as it is everywhere else
+    // in this protocol.
+    const payload    = Buffer.from(d.encPayload);
+    const ciphertext = payload.subarray(0, payload.length - 16);
+    const tag        = payload.subarray(payload.length - 16);
+
+    let plaintext;
+    try {
+      const dec = crypto.createDecipheriv('aes-256-gcm', voteKey, Buffer.from(d.encIv));
+      dec.setAAD(aad);
+      dec.setAuthTag(tag);
+      plaintext = Buffer.concat([dec.update(ciphertext), dec.final()]);
+    } catch (_) {
+      throw new Error('decryptPollVote: the ballot would not open — wrong encKey, ' +
+        'or the wrong voter/pollSender for this poll');
+    }
+
+    // PollVoteMessage { selectedOptions = 1, repeated bytes } — each entry is
+    // the SHA-256 of one option's text.
+    const { decodeFields } = require('./proto/MessageProto');
+    const parsed = decodeFields(plaintext);
+    const raw    = parsed[1] == null ? [] : (Array.isArray(parsed[1]) ? parsed[1] : [parsed[1]]);
+    const selectedHashes = raw.filter(Buffer.isBuffer);
+
+    let selected = [];
+    if (Array.isArray(opts.options) && opts.options.length) {
+      const byHash = new Map(opts.options.map(o => [
+        crypto.createHash('sha256').update(String(o), 'utf8').digest('hex'), String(o)
+      ]));
+      selected = selectedHashes
+        .map(h => byHash.get(h.toString('hex')))
+        .filter(o => o !== undefined);
+    }
+
+    return {
+      selected,
+      selectedHashes,
+      votedAt: d.senderTimestampMs != null ? d.senderTimestampMs : null
+    };
+  }
+
+  /**
+   * Unlink this device from the account.
+   *
+   * The companion asks the server to remove it, the same way the Linked Devices
+   * screen on the phone does, and then closes the connection. Everything on
+   * disk stays where it is — the session it describes no longer exists, so a
+   * later `connectWeb()` pairs afresh rather than trying to resume something
+   * the server has forgotten. Delete the session directory yourself if you want
+   * the keys gone as well.
+   *
+   * Web only: an account that registered its own number is not a companion and
+   * has nothing to unlink from.
+   *
+   * @returns {Promise<boolean>} whether the server accepted the removal
+   */
+  async logout() {
+    if (this._mode !== 'web') {
+      throw new Error('logout: only a companion can unlink itself — a session ' +
+        'that registered its own number has nothing to unlink from');
+    }
+    if (!this._socket || !this._connected) throw new Error('Not connected');
+
+    const ownJid = toNonAdJid(this._ownDeviceJid() || '');
+    if (!ownJid || ownJid.startsWith('@')) throw new Error('logout: not logged in');
+
+    let accepted = false;
+    try {
+      const resp = await this._sendIq(new BinaryNode('iq', {
+        id:    this._genMsgId(),
+        to:    's.whatsapp.net',
+        type:  'set',
+        xmlns: 'md'
+      }, [new BinaryNode('remove-companion-device', {
+        jid:    jidStrToObj(ownJid),
+        reason: 'user_initiated'
+      }, null)]));
+      accepted = !!(resp && !(resp.attrs && resp.attrs.type === 'error'));
+    } finally {
+      // The connection goes either way. A server that refused the removal is
+      // still a server we asked to be forgotten by, and staying connected on
+      // that basis is worse than dropping.
+      this.disconnect();
+    }
+    return accepted;
+  }
+
   // ─── Location ─────────────────────────────────────────────────────────────
   // sendLocation(to, latitude, longitude, opts)
   // opts: { name, address, url, id, contextInfo }

package/lib/DeviceConfig.js

@@ -55,9 +55,13 @@ function getDeviceConfig() {
     const profileKey = _normalise(process.env.WA_DEVICE || 'samsungs24ultra');
     const found = _ANDROID_MAP[profileKey] || null;
     if (found) {
-      return Object.assign({}, found, business
+      const picked = Object.assign({}, found, business
         ? { business: true, platform: PLATFORM.ANDROID_BUSINESS }
         : { business: false });
+      // A named profile carries the handset's own RAM; WA_DEVICE_RAM overrides
+      // it for someone running the same model in a different memory variant.
+      if (process.env.WA_DEVICE_RAM) picked.ram = process.env.WA_DEVICE_RAM;
+      return picked;
     }
 
     return {
@@ -69,6 +73,9 @@ function getDeviceConfig() {
       osVersion:       process.env.WA_DEVICE_OS_VERSION   || '14',
       osBuildNumber:   process.env.WA_DEVICE_BUILD        || 'UP1A.231005.007',
       modelId:         process.env.WA_DEVICE_MODEL_ID     || 'SM-S928B',
+      // What the handset reports as usable RAM, in GiB. Registration sends it,
+      // and it has to belong to the handset beside it — see deviceRam().
+      ram:             process.env.WA_DEVICE_RAM          || '11.55',
       deviceModelType: 2
     };
   }