@nexustechpro/baileys 2.1.2 → 2.1.6

package/lib/Socket/socket.js

@@ -36,9 +36,10 @@ import {
   makeNoiseHandler,
   promiseTimeout,
   signedKeyPair,
-  xmppSignedPreKey
+  xmppSignedPreKey,
+  getPlatformId,
+  isAndroidBrowser
 } from '../Utils/index.js'
-import { getPlatformId, migrateIndexKey } from '../Utils/index.js'
 import {
   assertNodeErrorFree,
   binaryNodeToString,
@@ -117,6 +118,12 @@ export const makeSocket = (config) => {
     })
   }
 
+  if (browser[1].toLocaleLowerCase().includes('android')) {
+    logger.warn(
+      '⚠️ Using the Android browser is experimental and may lead to unexpected behavior. Use at your own risk.'
+    )
+  }
+
   const ev = makeEventBuffer(logger)
   const { creds } = authState
   const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
@@ -629,8 +636,8 @@ export const makeSocket = (config) => {
         content: [
           { tag: 'link_code_pairing_wrapped_companion_ephemeral_pub', attrs: {}, content: await generatePairingKey() },
           { tag: 'companion_server_auth_key_pub', attrs: {}, content: authState.creds.noiseKey.public },
-          { tag: 'companion_platform_id', attrs: {}, content: getCompanionPlatformId(browser) },
-          { tag: 'companion_platform_display', attrs: {}, content: `${browser[1]} (${browser[0]})` },
+          { tag: 'companion_platform_id', attrs: {}, content: isAndroidBrowser(browser) ? getPlatformId('Chrome') : getCompanionPlatformId(browser) },
+          { tag: 'companion_platform_display', attrs: {}, content: isAndroidBrowser(browser) ? 'Chrome (Mac OS)' : `${browser[1]} (${browser[0]})` },
           { tag: 'link_code_pairing_nonce', attrs: {}, content: '0' }
         ]
       }]
@@ -747,7 +754,6 @@ export const makeSocket = (config) => {
     ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } })
     ev.emit('connection.update', { connection: 'open' })
     void sendUnifiedSession()
-
     if (node.attrs.lid && authState.creds.me?.id) {
       const myLID = node.attrs.lid
       process.nextTick(async () => {
@@ -755,23 +761,27 @@ export const makeSocket = (config) => {
           const myPN = authState.creds.me.id
           // Store own LID-PN mapping
           await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }])
-          // Build device-list using index-based batching to avoid unbounded key growth
+          // Write own device entry — one key per user, no index blob
           const { user, device } = jidDecode(myPN)
-          const currentBatch = await migrateIndexKey(authState.keys, 'device-list')
-          currentBatch[user] = [device?.toString() || '0']
-          const deviceKeys = Object.keys(currentBatch)
-          if (deviceKeys.length > BATCH_SIZE) {
-            deviceKeys.sort()
-            deviceKeys.slice(0, deviceKeys.length - BATCH_SIZE).forEach((k) => delete currentBatch[k])
-          }
-          await authState.keys.set({ 'device-list': { index: currentBatch } })
+          await authState.keys.set({ 'device-list': { [user]: [device?.toString() || '0'] } })
           // Migrate own session from PN → LID
           await signalRepository.migrateSession(myPN, myLID)
           logger.info({ myPN, myLID }, 'Own LID session created successfully')
-          // Batch-migrate any remaining PN sessions to LID
-          if (signalRepository.migrateAllPNSessionsToLID) {
+
+          // Migrate any other known PN sessions to LID (replaces removed migrateAllPNSessionsToLID)
+          if (signalRepository.lidMapping.getLIDPNMappings) {
             try {
-              const migrated = await signalRepository.migrateAllPNSessionsToLID()
+              const allMappings = await signalRepository.lidMapping.getLIDPNMappings()
+              const others = (allMappings || []).filter(m => m.pn !== myPN && m.lid && m.pn)
+              let migrated = 0
+              for (const { pn, lid } of others) {
+                try {
+                  await signalRepository.migrateSession(pn, lid)
+                  migrated++
+                } catch (sessErr) {
+                  logger.warn({ error: sessErr, pn, lid }, 'Failed to migrate individual PN session to LID')
+                }
+              }
               if (migrated > 0) logger.info({ migrated }, 'Batch-migrated PN sessions to LID on connect')
             } catch (migErr) {
               logger.warn({ error: migErr }, 'Failed to batch-migrate PN sessions to LID')
@@ -783,7 +793,6 @@ export const makeSocket = (config) => {
       })
     }
   })
-
   // ─── Stream / connection error handlers ─────────────────────────────────────
 
   ws.on('CB:stream:error', (node) => {

package/lib/Utils/browser-utils.js

@@ -18,11 +18,20 @@ export const Browsers = {
     macOS: browser => ['Mac OS', browser, '14.4.1'],
     baileys: browser => ['Baileys', browser, '6.5.0'],
     windows: browser => ['Windows', browser, '10.0.22631'],
+    android: browser => [browser, 'Android', ''],
     /** The appropriate browser based on your OS & release */
     appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
 };
 export const getPlatformId = (browser) => {
-    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
-    return platformType ? platformType.toString() : '1'; //chrome
-};
+    const upper = browser.toUpperCase()
+    if (upper === 'ANDROID') {
+        return proto.DeviceProps.PlatformType['ANDROID_PHONE'].toString()
+    }
+    const platformType = proto.DeviceProps.PlatformType[upper]
+    return platformType ? platformType.toString() : '1' // chrome
+}
+
+export const isAndroidBrowser = (browser) => {
+    return browser[1]?.toUpperCase() === 'ANDROID'
+}
 //# sourceMappingURL=browser-utils.js.map

package/lib/Utils/chat-utils.js

@@ -53,7 +53,7 @@ export const makeLtHashGenerator = ({ indexValueMap, hash }) => {
             }
             if (prevOp) subBuffs.push(prevOp.valueMac)
         },
-        finish: () => {
+        finish: async () => {
             const result = LT_HASH_ANTI_TAMPERING.subtractThenAdd(hash, subBuffs, addBuffs)
             return { hash: Buffer.from(result), indexValueMap }
         }
@@ -99,7 +99,7 @@ export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, op
     const indexMac = hmacSign(indexBuffer, keyValue.indexKey)
     const generator = makeLtHashGenerator(state)
     generator.mix({ indexMac, valueMac, operation })
-    Object.assign(state, generator.finish())
+    Object.assign(state, await generator.finish())
     state.version += 1
     const snapshotMac = generateSnapshotMac(state.hash, state.version, type, keyValue.snapshotMacKey)
     const patch = {

package/lib/Utils/key-store.js

@@ -1,17 +1,3 @@
 // ─── Key Store Helpers ─────────────────────────────────────────────────────────
 // Single source of truth for blob key names — change here, changes everywhere
-export const SESSION_INDEX_KEY = 'index'
-export const DEVICE_LIST_INDEX_KEY = 'index'
-
-// Migrates old _index blob to new index key in-place, returns the batch data
-export const migrateIndexKey = async (keys, type) => {
-    const oldKey = '_index'
-    const newKey = 'index'
-    const oldData = await keys.get(type, [oldKey])
-    if (oldData?.[oldKey] !== null && oldData?.[oldKey] !== undefined && typeof oldData[oldKey] === 'object') { // only migrate if old blob actually exists and has data
-        await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
-        return oldData[oldKey]
-    }
-    const newData = await keys.get(type, [newKey])
-    return newData?.[newKey] || {}
-}
+export const TC_TOKEN_INDEX_KEY = '__index'

package/lib/Utils/lt-hash.js

@@ -1,48 +1,7 @@
-import { hkdf } from './crypto.js';
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
 /**
  * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
  * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
  * if the same series of mutations was made sequentially.
  */
-const o = 128;
-class LTHash {
-    constructor(e) {
-        this.salt = e;
-    }
-    async add(e, t) {
-        for (const item of t) {
-            e = await this._addSingle(e, item);
-        }
-        return e;
-    }
-    async subtract(e, t) {
-        for (const item of t) {
-            e = await this._subtractSingle(e, item);
-        }
-        return e;
-    }
-    async subtractThenAdd(e, addList, subtractList) {
-        const subtracted = await this.subtract(e, subtractList);
-        return this.add(subtracted, addList);
-    }
-    async _addSingle(e, t) {
-        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
-    }
-    async _subtractSingle(e, t) {
-        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
-    }
-    performPointwiseWithOverflow(e, t, op) {
-        const n = new DataView(e);
-        const i = new DataView(t);
-        const out = new ArrayBuffer(n.byteLength);
-        const s = new DataView(out);
-        for (let offset = 0; offset < n.byteLength; offset += 2) {
-            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
-        }
-        return out;
-    }
-}
-export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');
-//# sourceMappingURL=lt-hash.js.map
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/lib/Utils/messages-media.js

@@ -235,35 +235,40 @@ export async function getAudioWaveform(buffer, logger) {
 
 // ─── FFMPEG CONVERTERS ────────────────────────────────────────────────────────
 const convertToOpusBuffer = async (buffer, logger) => {
+    if (buffer[0] === 0x4F && buffer[1] === 0x67 && buffer[2] === 0x67 && buffer[3] === 0x53) return buffer
     const ffmpegPath = await getFfmpegPath()
     const inputPath = join(tmpdir(), 'opus-in-' + generateMessageIDV2())
+    const outputPath = join(tmpdir(), 'opus-out-' + generateMessageIDV2() + '.ogg')
     await fs.writeFile(inputPath, buffer)
     try {
-        return await new Promise((resolve, reject) => {
-            const ff = spawn(ffmpegPath, ['-y', '-i', inputPath, '-c:a', 'libopus', '-b:a', '64k', '-vbr', 'on', '-compression_level', '10', '-frame_duration', '20', '-application', 'voip', '-f', 'ogg', 'pipe:1'], { stdio: ['ignore', 'pipe', 'pipe'] })
-            const chunks = []
-            ff.stdout.on('data', chunk => chunks.push(chunk))
-            ff.stderr.on('data', () => { })
-            ff.on('close', code => code === 0 ? resolve(Buffer.concat(chunks)) : reject(new Error(`FFmpeg Opus exited with code ${code}`)))
+        await new Promise((resolve, reject) => {
+            const ff = spawn(ffmpegPath, ['-y', '-i', inputPath, '-c:a', 'libopus', '-b:a', '128k', '-ar', '48000', '-ac', '1', '-vbr', 'on', '-compression_level', '10', '-frame_duration', '20', '-application', 'audio', '-map_metadata', '-1', outputPath], { stdio: ['ignore', 'ignore', 'pipe'] })
+            ff.on('close', code => code === 0 ? resolve() : reject(new Error(`FFmpeg Opus exited with code ${code}`)))
             ff.on('error', reject)
         })
+        return await fs.readFile(outputPath)
     } finally {
         try { await fs.unlink(inputPath) } catch { }
+        try { await fs.unlink(outputPath) } catch { }
     }
 }
 
 const convertToMp4Buffer = async (buffer, logger) => {
     const ffmpegPath = await getFfmpegPath()
-    return new Promise((resolve, reject) => {
-        const ff = spawn(ffmpegPath, ['-i', 'pipe:0', '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '23', '-c:a', 'aac', '-b:a', '128k', '-movflags', 'faststart', '-f', 'mp4', 'pipe:1'], { stdio: ['pipe', 'pipe', 'pipe'] })
-        const chunks = []
-        ff.stdin.write(buffer)
-        ff.stdin.end()
-        ff.stdout.on('data', chunk => chunks.push(chunk))
-        ff.stderr.on('data', () => { })
-        ff.on('close', code => code === 0 ? resolve(Buffer.concat(chunks)) : reject(new Error(`FFmpeg MP4 exited with code ${code}`)))
-        ff.on('error', reject)
-    })
+    const inputPath = join(osTmpdir(), 'mp4-in-' + generateMessageIDV2())
+    const outputPath = join(osTmpdir(), 'mp4-out-' + generateMessageIDV2() + '.mp4')
+    await fs.writeFile(inputPath, buffer)
+    try {
+        await new Promise((resolve, reject) => {
+            const ff = spawn(ffmpegPath, ['-y', '-i', inputPath, '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '23', '-pix_fmt', 'yuv420p', '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2', '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', '-map_metadata', '-1', outputPath], { stdio: ['ignore', 'ignore', 'pipe'] })
+            ff.on('close', code => code === 0 ? resolve() : reject(new Error(`FFmpeg MP4 exited with code ${code}`)))
+            ff.on('error', reject)
+        })
+        return await fs.readFile(outputPath)
+    } finally {
+        try { await fs.unlink(inputPath) } catch { }
+        try { await fs.unlink(outputPath) } catch { }
+    }
 }
 
 // ─── STREAM UTILS ─────────────────────────────────────────────────────────────

package/lib/Utils/messages.js

@@ -317,9 +317,11 @@ const handleButtonReply = (message) => {
 
 // ─── MAIN GENERATOR ───────────────────────────────────────────────────────────
 export const generateWAMessageContent = async (message, options = {}) => {
-    const messageKeys = Object.keys(message)
+    const messageKeys = (message && typeof message === 'object') ? Object.keys(message) : []
     const isRawProtoMessage = messageKeys.some(k => k.endsWith('Message') && typeof message[k] === 'object' && !HIGH_LEVEL_KEYS.includes(k))
-    const isWrapperMessage = ['viewOnceMessage', 'ephemeralMessage', 'viewOnceMessageV2', 'documentWithCaptionMessage'].some(k => k in message)
+    const isWrapperMessage = (message && typeof message === 'object')
+        ? ['viewOnceMessage', 'ephemeralMessage', 'viewOnceMessageV2', 'documentWithCaptionMessage'].some(k => k in message)
+        : false
     if ((isRawProtoMessage || isWrapperMessage) && messageKeys.length === 1) return WAProto.Message.create(message)
     if (!messageKeys.some(k => HIGH_LEVEL_KEYS.includes(k)) && isRawProtoMessage) return WAProto.Message.create(message)