whalibmob 5.1.21 → 5.5.22

package/lib/DeviceManager.js

@@ -18,6 +18,28 @@ function makeDeviceJid(user, device, server) {
   return `${user}:${device}@${server}`;
 }
 
+// Convert a JID string like "user@server" or "user:device@server" into the
+// BinaryNode JID object format so _writeJid() emits proper binary JID_PAIR /
+// AD_JID bytes instead of raw UTF-8.  The server requires binary JID encoding
+// for routing attributes — raw UTF-8 strings are silently ignored for @lid JIDs.
+function jidStrToObj(jidStr) {
+  const str    = typeof jidStr === 'string' ? jidStr : String(jidStr);
+  const at     = str.indexOf('@');
+  const raw    = at >= 0 ? str.slice(0, at) : str;
+  const server = at >= 0 ? str.slice(at + 1) : 's.whatsapp.net';
+  const colon  = raw.indexOf(':');
+  const user   = colon >= 0 ? raw.slice(0, colon) : raw;
+  const device = colon >= 0 ? (parseInt(raw.slice(colon + 1), 10) || 0) : 0;
+  const self   = str;
+  // AD_JID binary format requires both agent AND device fields — use only for
+  // multi-device @s.whatsapp.net JIDs where device > 0.
+  if (server === 's.whatsapp.net' && device > 0) {
+    return { user, agent: 0, device, server, toString() { return self; } };
+  }
+  // JID_PAIR: used for @lid, @g.us, and primary (device-0) @s.whatsapp.net
+  return { user, server, toString() { return self; } };
+}
+
 function phoneFromJid(jid) {
   const { user } = stripUser(jid);
   return user;
@@ -119,30 +141,70 @@ class DeviceManager {
 
   // ─── Fetch pre-key bundles for a list of JIDs via encrypt IQ ───────────────
   // Only called for JIDs where no Signal session exists yet.
-  // Returns Map<jid, bundle>
+  // Returns Map<string_jid, bundle> — keys are always normalised strings.
   async fetchBundles(jids) {
     if (!jids || jids.length === 0) return new Map();
 
-    const userNodes = jids.map(jid => { const lidMatch = jid.match(/(\d{15,})@s\.whatsapp\.net/); return new BinaryNode('user', { jid }, null); });
+    // Convert a string JID like "user@server" or "user:device@server" into
+    // a proper JID object so the binary encoder uses JID_PAIR / AD_JID format.
+    // Raw UTF-8 strings are NOT recognised by the WA server for @lid JIDs — the
+    // server silently ignores unknown JIDs and returns an empty bundle list.
+    const toJidObj = jidStr => {
+      const str    = typeof jidStr === 'string' ? jidStr : String(jidStr);
+      const at     = str.indexOf('@');
+      const raw    = at >= 0 ? str.slice(0, at) : str;
+      const server = at >= 0 ? str.slice(at + 1) : 's.whatsapp.net';
+      const colon  = raw.indexOf(':');
+      const user   = colon >= 0 ? raw.slice(0, colon) : raw;
+      const device = colon >= 0 ? (parseInt(raw.slice(colon + 1), 10) || 0) : 0;
+      const self   = str;
+      // AD_JID binary format is for @s.whatsapp.net with device > 0.
+      // JID_PAIR binary format is used for @lid and for device-0 @s.whatsapp.net.
+      if (server === 's.whatsapp.net' && device > 0) {
+        // AD_JID: agent=0, device=N
+        return { user, agent: 0, device, server, toString() { return self; } };
+      }
+      // JID_PAIR: user@server  — server may be 'lid' or 's.whatsapp.net'
+      return { user, server, toString() { return self; } };
+    };
+
+    const userNodes = jids.map(jid => new BinaryNode('user', { jid: toJidObj(jid) }, null));
     const iqId   = this._client._genMsgId();
     const iqNode = new BinaryNode('iq',
       { id: iqId, xmlns: 'encrypt', type: 'get', to: 's.whatsapp.net' },
       [new BinaryNode('key', {}, userNodes)]
     );
 
+    process.stderr.write('[DBG] FETCH_BUNDLES jids=[' + jids.join(',') + ']\n');
+
     const response = await this._client._sendIq(iqNode);
     const bundles  = new Map();
-    if (!response) return bundles;
+    if (!response) {
+      process.stderr.write('[DBG] FETCH_BUNDLES_NULL\n');
+      return bundles;
+    }
 
     const listNode = findChild(response, 'list');
     const children = listNode ? listNode.content : (response.content || []);
+
+    process.stderr.write('[DBG] FETCH_BUNDLES_RESP childCount=' +
+      (Array.isArray(children) ? children.length : 0) + '\n');
+
     for (const userNode of (Array.isArray(children) ? children : [])) {
       if (!userNode || userNode.description !== 'user') continue;
-      const jid = userNode.attrs && userNode.attrs.jid;
-      if (!jid) continue;
+      const jidRaw = userNode.attrs && userNode.attrs.jid;
+      if (!jidRaw) continue;
+      // Always normalise to a string key so Map lookups are consistent
+      const jidStr = String(jidRaw);
+      process.stderr.write('[DBG] FETCH_BUNDLES_USER jid=' + jidStr +
+        ' childTags=' + (Array.isArray(userNode.content)
+          ? userNode.content.map(c => c && c.description).filter(Boolean).join(',')
+          : '') + '\n');
       const bundle = parseBundleFromUserNode(userNode);
-      if (bundle) bundles.set(jid, bundle);
+      if (bundle) bundles.set(jidStr, bundle);
+      else process.stderr.write('[DBG] FETCH_BUNDLES_NO_BUNDLE jid=' + jidStr + '\n');
     }
+    process.stderr.write('[DBG] FETCH_BUNDLES_DONE count=' + bundles.size + '\n');
     return bundles;
   }
 
@@ -198,54 +260,158 @@ class DeviceManager {
     return jids.length > 0 ? jids : phones.map(p => makeDeviceJid(p, 0));
   }
 
-  // Actual usync IQ — only called for phones NOT in _deviceCache
+  // ─── FIXED usync IQ — corrects 4 bugs in the original implementation ────────
+  //
+  //  Bug 1 — Wrong <list> node format:
+  //    Was:  <user><contact>+phone</contact></user>
+  //    Fix:  <user jid="phone@s.whatsapp.net"/>     (jid ATTRIBUTE, not contact child)
+  //
+  //  Bug 2 — Wrong <query><devices> node:
+  //    Was:  <devices version="2"><device jid="phone@s.whatsapp.net"/></devices>
+  //    Fix:  <devices version="2"/>                  (NO device children in query)
+  //
+  //  Bug 3 — Missing <side_list/> node:
+  //    Was:  (absent)
+  //    Fix:  <side_list/>                            (required for LID device discovery)
+  //
+  //  Bug 4 — Wrong response parser:
+  //    Was:  deep walk looking for <device jid="..."> attrs
+  //    Fix:  navigate  usync → list → user[jid=...] → devices → device-list → device[id=N]
+  //          Server returns <device id="0"/>  NOT <device jid="..."/>
+  //          The phone/LID identifier is on the PARENT <user jid="..."> node, not on device.
+  //
   async _doUsyncIq(phones) {
     const iqId = this._client._genMsgId();
     const sid  = this._client._genMsgId();
 
+    // FIX Bug 1: jid attribute on <user>, not a <contact> child node
+    // FIX Bug 2: <devices version="2"/> with NO children
     const listChildren = phones.map(p =>
-      new BinaryNode('user', {},
-        [new BinaryNode('contact', {}, Buffer.from('+' + p))]
-      )
-    );
-    const deviceChildren = phones.map(p =>
-      new BinaryNode('device', { jid: makeDeviceJid(p, 0) }, null)
+      new BinaryNode('user', { jid: `${p}@s.whatsapp.net` }, null)
     );
 
     const iqNode = new BinaryNode('iq',
       { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
       [new BinaryNode('usync',
-        { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
         [
           new BinaryNode('query', {},
-            [new BinaryNode('devices', { version: '2' }, deviceChildren)]
+            [new BinaryNode('devices', { version: '2' }, null)]   // FIX Bug 2: null, not deviceChildren
           ),
-          new BinaryNode('list', {}, listChildren)
+          new BinaryNode('list', {}, listChildren),
+          new BinaryNode('side_list', {}, null)                    // FIX Bug 3: required node
         ]
       )]
     );
 
-    const response = await this._client._sendIq(iqNode).catch(() => null);
-
-    // Walk response and populate cache
-    const found = new Set();
-    function walk(node) {
-      if (!node) return;
-      if (node.description === 'device' && node.attrs && node.attrs.jid) {
-        const jid = node.attrs.jid;
-        const { user, device } = stripUser(jid);
-        if (!found.has(user)) found.add(user);
-        if (!this._deviceCache.has(user)) this._deviceCache.set(user, new Set());
-        this._deviceCache.get(user).add(device);
+    process.stderr.write('[DBG] USYNC_IQ phones=[' + phones.join(',') + ']\n');
+
+    const response = await this._client._sendIq(iqNode).catch(err => {
+      process.stderr.write('[DBG] USYNC_ERR ' + (err && err.message) + '\n');
+      return null;
+    });
+
+    // FIX Bug 4: Correct response structure is:
+    //   <usync>
+    //     <list>
+    //       <user jid="phone@s.whatsapp.net" [lid="lid_user@lid"]>
+    //         <devices>
+    //           <device-list>
+    //             <device id="0"/>
+    //             <device id="2"/>
+    //           </device-list>
+    //         </devices>
+    //       </user>
+    //     </list>
+    //   </usync>
+    if (response) {
+      const usyncNode = findChild(response, 'usync');
+      const listNode  = usyncNode
+        ? findChild(usyncNode, 'list')
+        : findChild(response, 'list');
+
+      if (listNode && Array.isArray(listNode.content)) {
+        for (const userNode of listNode.content) {
+          if (!userNode || userNode.description !== 'user') continue;
+
+          const userJid = userNode.attrs && (userNode.attrs.jid || userNode.attrs.value);
+          if (!userJid) continue;
+
+          const isLidUser = String(userJid).endsWith('@lid');
+          const { user: rawUser } = stripUser(String(userJid));
+
+          // Determine phone-based cache key (always a phone number, never a LID)
+          let cachePhone;
+          if (isLidUser) {
+            // Modern account: server returned LID JID in the user node
+            const pn = this._client._lidToPn && this._client._lidToPn.get(rawUser);
+            if (pn) {
+              cachePhone = pn;
+            } else if (phones.length === 1) {
+              // Single phone queried — this LID must belong to it
+              cachePhone = phones[0];
+              if (this._client._lidToPn) this._client._lidToPn.set(rawUser, phones[0]);
+              if (this._client._pnToLid) this._client._pnToLid.set(phones[0], rawUser);
+            } else {
+              cachePhone = rawUser; // last resort: use LID user as key
+            }
+            process.stderr.write('[DBG] USYNC_LID_USER userJid=' + userJid + ' → cachePhone=' + cachePhone + '\n');
+          } else {
+            // Normal account: user JID is phone@s.whatsapp.net
+            cachePhone = rawUser;
+
+            // Also extract LID from user node's `lid` attribute if the server provided it
+            const lidAttr = userNode.attrs && userNode.attrs.lid;
+            if (lidAttr) {
+              const lidUser = String(lidAttr).split('@')[0].split(':')[0];
+              if (this._client._lidToPn) this._client._lidToPn.set(lidUser, cachePhone);
+              if (this._client._pnToLid) this._client._pnToLid.set(cachePhone, lidUser);
+              process.stderr.write('[DBG] USYNC_LID_MAP phone=' + cachePhone + ' ↔ lid=' + lidUser + '\n');
+            }
+          }
+
+          // Navigate user → devices → device-list → device[id=N]
+          const devicesNode    = findChild(userNode, 'devices');
+          const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
+
+          if (!this._deviceCache.has(cachePhone)) {
+            this._deviceCache.set(cachePhone, new Set());
+          }
+
+          if (deviceListNode && Array.isArray(deviceListNode.content)) {
+            for (const devNode of deviceListNode.content) {
+              if (!devNode || devNode.description !== 'device') continue;
+              // FIX: server uses `id` attribute (e.g. id="0"), NOT `jid` attribute
+              const devId = devNode.attrs && devNode.attrs.id != null
+                ? parseInt(String(devNode.attrs.id), 10)
+                : 0;
+              this._deviceCache.get(cachePhone).add(devId);
+            }
+            process.stderr.write('[DBG] USYNC_DEVICES phone=' + cachePhone +
+              ' ids=[' + [...this._deviceCache.get(cachePhone)].join(',') + ']\n');
+          } else {
+            // No device-list in response — fall back to device 0
+            this._deviceCache.get(cachePhone).add(0);
+            process.stderr.write('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
+          }
+        }
+      } else {
+        process.stderr.write('[DBG] USYNC_RESP_NO_LIST\n');
       }
-      if (Array.isArray(node.content)) node.content.forEach(walk.bind(this));
+    } else {
+      process.stderr.write('[DBG] USYNC_NULL_RESP\n');
+      // Device usync timed out — fall back to a contact usync (query/contact).
+      // This DOES receive a server response and resolves the phone → LID mapping.
+      // Once _pnToLid is populated here, _sendDMMessage (after its await) will
+      // use the LID JID for routing instead of the stale phone JID.
+      await this._doContactUsync(phones).catch(() => {});
     }
-    if (response) walk.call(this, response);
 
-    // For any phone that returned no devices, cache device=0 so we don't query again
+    // For phones with no usync response at all, cache device 0 so we don't re-query
     for (const p of phones) {
       if (!this._deviceCache.has(p)) {
         this._deviceCache.set(p, new Set([0]));
+        process.stderr.write('[DBG] USYNC_FALLBACK phone=' + p + '\n');
       }
     }
   }
@@ -297,6 +463,217 @@ class DeviceManager {
     return readyJids;
   }
 
+  // ─── Ensure sessions for a LID-addressed recipient ────────────────────────
+  //
+  // For accounts migrated to WhatsApp LID, devices are registered under the
+  // LID identity (e.g. 139471160877194@lid), NOT the phone number.
+  // This method:
+  //   1. Queries usync for device list by LID JID
+  //   2. Establishes Signal sessions for LID device JIDs (e.g. 139471160877194:0@lid)
+  //   3. Returns the list of ready LID device JIDs for participant fanout
+  //
+  async bulkEnsureSessionsForLid(lidUser, signalProto, allowPkmsg = true, skipUsync = false) {
+    const lidJid    = `${lidUser}@lid`;
+    const cacheKey  = `lid:${lidUser}`;
+
+    // skipUsync=true: caller already knows the LID (from _pnToLid) — skip the
+    // usync round-trip and assume primary device 0.  Saves up to 15 s.
+    if (skipUsync) {
+      if (!this._deviceCache.has(cacheKey)) {
+        this._deviceCache.set(cacheKey, new Set([0]));
+        process.stderr.write('[DBG] LID_SKIP_USYNC lidUser=' + lidUser + ' assume device=0\n');
+      }
+    } else if (!this._deviceCache.has(cacheKey)) {
+      await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
+    }
+
+    const deviceIds  = this._deviceCache.get(cacheKey) || new Set([0]);
+    const deviceJids = [...deviceIds].map(d => makeDeviceJid(lidUser, d, 'lid'));
+
+    process.stderr.write('[DBG] LID_DEVICES lidUser=' + lidUser +
+      ' deviceJids=[' + deviceJids.join(',') + ']\n');
+
+    // Split: existing sessions (ready) vs new (need bundle fetch)
+    const readyJids = [];
+    const fetchJids = [];
+    for (const jid of deviceJids) {
+      if (signalProto.store.hasSession(this._jidToAddr(jid))) {
+        readyJids.push(jid);
+      } else {
+        fetchJids.push(jid);
+      }
+    }
+
+    if (allowPkmsg && fetchJids.length > 0) {
+      const bundles = await this.fetchBundles(fetchJids);
+      for (const [jid, bundle] of bundles) {
+        try {
+          await signalProto.buildSessionFromBundle(jid, bundle);
+          readyJids.push(jid);
+          process.stderr.write('[DBG] LID_SESSION_BUILT jid=' + jid + '\n');
+        } catch (e) {
+          process.stderr.write('[DBG] LID_SESSION_ERR jid=' + jid + ' err=' + e.message + '\n');
+        }
+      }
+    }
+
+    // Fallback: use primary LID device 0 directly (no session yet, will use pkmsg)
+    if (readyJids.length === 0) {
+      readyJids.push(makeDeviceJid(lidUser, 0, 'lid'));
+    }
+
+    return readyJids;
+  }
+
+  // ─── Contact usync fallback ────────────────────────────────────────────────
+  // When query/devices usync times out (server silently ignores it for LID
+  // accounts), we fall back to query/contact which uses the older
+  // <user><contact>+phone</contact></user> format and DOES get a response.
+  // The response includes the actual JID (LID or PN) for each phone.
+  // Calling this populates _pnToLid / _lidToPn in the Client, which is used
+  // by _sendDMMessage (checked AFTER the await of _usyncGetDevices).
+  async _doContactUsync(phones) {
+    const iqId = this._client._genMsgId();
+    const sid  = this._client._genMsgId();
+
+    const userNodes = phones.map(p =>
+      new BinaryNode('user', {}, [
+        new BinaryNode('contact', {}, Buffer.from('+' + p, 'utf8'))
+      ])
+    );
+
+    const iqNode = new BinaryNode('iq',
+      { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
+      [new BinaryNode('usync',
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
+        [
+          new BinaryNode('query', {}, [new BinaryNode('contact', {}, null)]),
+          new BinaryNode('list', {}, userNodes),
+          new BinaryNode('side_list', {}, null)
+        ]
+      )]
+    );
+
+    process.stderr.write('[DBG] CONTACT_USYNC phones=[' + phones.join(',') + ']\n');
+
+    const response = await this._client._sendIq(iqNode).catch(err => {
+      process.stderr.write('[DBG] CONTACT_USYNC_ERR ' + (err && err.message) + '\n');
+      return null;
+    });
+
+    if (!response) {
+      process.stderr.write('[DBG] CONTACT_USYNC_NULL\n');
+      return;
+    }
+
+    const usyncNode = findChild(response, 'usync');
+    const listNode  = usyncNode ? findChild(usyncNode, 'list') : findChild(response, 'list');
+
+    if (!listNode || !Array.isArray(listNode.content)) {
+      process.stderr.write('[DBG] CONTACT_USYNC_NO_LIST\n');
+      return;
+    }
+
+    for (let i = 0; i < listNode.content.length; i++) {
+      const userNode = listNode.content[i];
+      if (!userNode || userNode.description !== 'user') continue;
+
+      const actualJid = userNode.attrs && (userNode.attrs.jid || userNode.attrs.value);
+      if (!actualJid) continue;
+
+      const actualJidStr = String(actualJid);
+      const isLid = actualJidStr.endsWith('@lid');
+
+      if (isLid) {
+        const { user: lidUser } = stripUser(actualJidStr);
+        // Determine the corresponding phone.  For single-phone queries it's
+        // unambiguous; for multi-phone queries match by index.
+        const phone = phones.length === 1 ? phones[0] : phones[i];
+        if (phone) {
+          process.stderr.write('[DBG] CONTACT_USYNC_LID phone=' + phone + ' → lid=' + lidUser + '\n');
+          if (this._client._pnToLid) this._client._pnToLid.set(phone, lidUser);
+          if (this._client._lidToPn) this._client._lidToPn.set(lidUser, phone);
+          // Persist the mapping so future sessions don't need to re-query
+          const store = this._client._signal && this._client._signal.store;
+          if (store && store.setLidMapping) store.setLidMapping(phone, lidUser);
+        }
+      } else {
+        // PN account — note it (still on phone-based routing, no LID needed)
+        const { user: pnUser } = stripUser(actualJidStr);
+        const phone = phones.length === 1 ? phones[0] : phones[i];
+        process.stderr.write('[DBG] CONTACT_USYNC_PN phone=' + phone + ' jid=' + actualJidStr + '\n');
+      }
+    }
+  }
+
+  // ─── usync IQ for a specific JID (LID or phone-based) ─────────────────────
+  // Used when we already know the routing JID and want to look up devices for it.
+  async _doUsyncIqByJid(jid, cacheKey, lidUser) {
+    const iqId = this._client._genMsgId();
+    const sid  = this._client._genMsgId();
+
+    const iqNode = new BinaryNode('iq',
+      { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
+      [new BinaryNode('usync',
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
+        [
+          new BinaryNode('query', {},
+            [new BinaryNode('devices', { version: '2' }, null)]
+          ),
+          new BinaryNode('list', {},
+            [new BinaryNode('user', { jid }, null)]
+          ),
+          new BinaryNode('side_list', {}, null)
+        ]
+      )]
+    );
+
+    process.stderr.write('[DBG] USYNC_LID_IQ jid=' + jid + '\n');
+
+    const response = await this._client._sendIq(iqNode).catch(err => {
+      process.stderr.write('[DBG] USYNC_LID_IQ_ERR ' + (err && err.message) + '\n');
+      return null;
+    });
+
+    if (!this._deviceCache.has(cacheKey)) {
+      this._deviceCache.set(cacheKey, new Set());
+    }
+
+    if (response) {
+      const usyncNode = findChild(response, 'usync');
+      const listNode  = usyncNode ? findChild(usyncNode, 'list') : findChild(response, 'list');
+
+      if (listNode && Array.isArray(listNode.content)) {
+        for (const userNode of listNode.content) {
+          if (!userNode || userNode.description !== 'user') continue;
+
+          const devicesNode    = findChild(userNode, 'devices');
+          const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
+
+          if (deviceListNode && Array.isArray(deviceListNode.content)) {
+            for (const devNode of deviceListNode.content) {
+              if (!devNode || devNode.description !== 'device') continue;
+              const devId = devNode.attrs && devNode.attrs.id != null
+                ? parseInt(String(devNode.attrs.id), 10) : 0;
+              this._deviceCache.get(cacheKey).add(devId);
+            }
+            process.stderr.write('[DBG] USYNC_LID_DEVICES jid=' + jid +
+              ' ids=[' + [...this._deviceCache.get(cacheKey)].join(',') + ']\n');
+          } else {
+            this._deviceCache.get(cacheKey).add(0);
+            process.stderr.write('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
+          }
+        }
+      } else {
+        process.stderr.write('[DBG] USYNC_LID_NO_LIST jid=' + jid + '\n');
+        this._deviceCache.get(cacheKey).add(0);
+      }
+    } else {
+      process.stderr.write('[DBG] USYNC_LID_NULL_RESP jid=' + jid + '\n');
+      this._deviceCache.get(cacheKey).add(0);
+    }
+  }
+
   // ─── Ensure sessions for own linked devices (device != 0) ─────────────────
   //
   // OPTIMISATION: own device list is cached for the entire connection lifetime.
@@ -365,7 +742,11 @@ class DeviceManager {
     const toNodes = encryptedList.map(({ jid, type, ciphertext }) => {
       const encAttrs = { type, v: '2' };
       if (mediaSubtype) encAttrs.mediatype = mediaSubtype;
-      return new BinaryNode('to', { jid },
+      // Always encode the jid as a binary JID object (JID_PAIR / AD_JID) so the
+      // server can route the per-device enc payload to the correct Signal session.
+      // Raw UTF-8 strings are silently dropped for @lid recipients.
+      const jidAttr = jidStrToObj(jid);
+      return new BinaryNode('to', { jid: jidAttr },
         [new BinaryNode('enc', encAttrs, ciphertext)]
       );
     });
@@ -373,4 +754,4 @@ class DeviceManager {
   }
 }
 
-module.exports = { DeviceManager, makeDeviceJid, stripUser, phoneFromJid, parseBundleFromUserNode };
+module.exports = { DeviceManager, makeDeviceJid, stripUser, phoneFromJid, parseBundleFromUserNode, jidStrToObj };

package/lib/MediaService.js

@@ -120,7 +120,7 @@ function _tryUpload(host, mediaPath, token, auth, encrypted, encSha256, sha256)
         'Content-Type':   'application/octet-stream',
         'Content-Length': encrypted.length,
         'Accept':         'application/json',
-        'User-Agent':     (() => { const d = getDeviceConfig(); return `WhatsApp/${d.version || '2.26.10.74'} iOS/${d.osVersion} Device/${d.model}`; })()
+        'User-Agent':     (() => { const d = getDeviceConfig(); return d.os === 'android' ? `WhatsApp/${d.version || '2.26.7.75'} A` : `WhatsApp/${d.version || '2.26.7.75'} iOS/${d.osVersion} Device/${d.model}`; })()
       }
     };