@nexustechpro/baileys 2.1.0 → 2.1.3

package/lib/Utils/key-store.js

@@ -2,16 +2,21 @@
 // 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'
+export const TC_TOKEN_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 oldKeys = ['_index', '__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]
+
+    for (const oldKey of oldKeys) {
+        const oldData = await keys.get(type, [oldKey])
+        if (oldData?.[oldKey] !== null && oldData?.[oldKey] !== undefined && typeof oldData[oldKey] === 'object') {
+            await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
+            return oldData[oldKey]
+        }
     }
+
     const newData = await keys.get(type, [newKey])
     return newData?.[newKey] || {}
 }

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.js

@@ -334,7 +334,10 @@ export const generateWAMessageContent = async (message, options = {}) => {
         } else if ('groupInvite' in message) {
             m = await handleGroupInvite(message, options)
         } else if ('stickerPack' in message) {
-            return WAProto.Message.create({ stickerPackMessage: (await prepareStickerPackMessage(message.stickerPack, options)).stickerPackMessage })
+            const result = await prepareStickerPackMessage(message.stickerPack, options)
+            return result.isBatched
+                ? { stickerPackMessage: result.stickerPackMessage, isBatched: true, batchCount: result.batchCount }
+                : WAProto.Message.create({ stickerPackMessage: result.stickerPackMessage })
         } else if ('pin' in message) {
             const messageKey = typeof message.pin === 'boolean'
                 ? (options.quoted?.key || (() => { throw new Boom('No quoted message key found for pin operation') })())
@@ -460,81 +463,99 @@ export const generateWAMessageContent = async (message, options = {}) => {
 // ─── STICKER PACK ─────────────────────────────────────────────────────────────
 export const prepareStickerPackMessage = async (stickerPack, options) => {
     const { stickers, cover, name, publisher, packId, description } = stickerPack
-    if (!stickers?.length) throw new Boom('Sticker pack requires at least one sticker', { statusCode: 400 })
-    if (stickers.length > 120) throw new Boom('Sticker pack exceeds maximum of 120 stickers', { statusCode: 400 })
+    const MAX_STICKER_SIZE = 1024 * 1024
+    const MAX_STICKERS_PER_PACK = 60
 
+    if (!stickers?.length) throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 })
+
+    const stickerPackIdValue = packId || generateMessageIDV2()
     const lib = await getImageProcessingLibrary()
-    const packId_ = packId || generateMessageIDV2()
+    const validStickers = []
+    const skippedStickers = []
 
     const isWebPBuffer = (buf) => buf.length >= 12 && buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 && buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50
-    const isAnimatedWebP = (buf) => {
-        if (!isWebPBuffer(buf)) return false
-        let offset = 12
-        while (offset < buf.length - 8) {
-            const fourCC = buf.toString('ascii', offset, offset + 4)
-            const chunkSize = buf.readUInt32LE(offset + 4)
-            if (fourCC === 'VP8X' && offset + 8 < buf.length && (buf[offset + 8] & 0x02)) return true
-            if (fourCC === 'ANIM' || fourCC === 'ANMF') return true
-            offset += 8 + chunkSize + (chunkSize % 2)
-        }
-        return false
-    }
-    const toWebp = async (buffer) => {
-        if ('sharp' in lib && lib.sharp) return await lib.sharp.default(buffer).resize(512, 512, { fit: 'inside', withoutEnlargement: true }).webp({ quality: 75, effort: 6 }).toBuffer()
-        if ('jimp' in lib && lib.jimp) return await lib.jimp.Jimp.read(buffer).then(img => img.getBuffer('image/webp'))
-        throw new Boom('No image processing library available', { statusCode: 500 })
-    }
 
-    const validStickers = []
-    await Promise.all(stickers.map(async (s) => {
+    const stickerPromises = stickers.map(async (s, i) => {
         try {
             const { stream } = await getStream(s.data || s.sticker)
             const buffer = await toBuffer(stream)
-            if (!buffer?.length) return
-            const animated = isAnimatedWebP(buffer)
-            let webpBuffer = isWebPBuffer(buffer) ? buffer : await toWebp(buffer)
-            if (webpBuffer.length > 1024 * 1024) {
-                if ('sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(webpBuffer).webp({ quality: 50 }).toBuffer()
-                if (webpBuffer.length > 1024 * 1024) return
+            if (!buffer?.length) { skippedStickers.push({ index: i, reason: 'Empty buffer' }); return null }
+
+            const isWebP = isWebPBuffer(buffer)
+            let webpBuffer
+            try {
+                if (isWebP) webpBuffer = buffer
+                else if ('sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(buffer).webp().toBuffer()
+                else if ('jimp' in lib && lib.jimp) webpBuffer = await lib.jimp.Jimp.read(buffer).then(img => img.getBuffer('image/webp'))
+                else { skippedStickers.push({ index: i, reason: 'No image processing library' }); return null }
+            } catch (convertError) {
+                if (!isWebP) { skippedStickers.push({ index: i, reason: `Conversion failed: ${convertError.message}` }); return null }
+                throw convertError
+            }
+
+            if (webpBuffer.length > MAX_STICKER_SIZE) {
+                options.logger?.warn?.(`Sticker at index ${i} exceeds 1MB, compressing...`)
+                try {
+                    if ('sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(buffer).webp({ quality: 70 }).toBuffer()
+                    if (webpBuffer.length > MAX_STICKER_SIZE && 'sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(buffer).webp({ quality: 50 }).toBuffer()
+                    if (webpBuffer.length > MAX_STICKER_SIZE) { skippedStickers.push({ index: i, reason: 'Still exceeds 1MB after compression' }); return null }
+                    options.logger?.info?.(`Sticker ${i} compressed successfully`)
+                } catch {
+                    skippedStickers.push({ index: i, reason: 'Compression failed' })
+                    return null
+                }
             }
+
             const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-').replace(/=/g, '')
-            validStickers.push({ fileName: `${hash}.webp`, buffer: webpBuffer, mimetype: 'image/webp', isAnimated: s.isAnimated ?? animated, isLottie: s.isLottie || false, emojis: s.emojis || [], accessibilityLabel: s.accessibilityLabel || '' })
-        } catch (e) { options.logger?.warn({ err: e }, 'failed processing sticker') }
-    }))
+            return { fileName: `${hash}.webp`, webpBuffer, mimetype: 'image/webp', isAnimated: s.isAnimated || false, isLottie: s.isLottie || false, emojis: s.emojis || [], accessibilityLabel: s.accessibilityLabel || '' }
+        } catch (e) {
+            options.logger?.warn({ err: e }, 'failed processing sticker')
+            skippedStickers.push({ index: i, reason: e.message })
+            return null
+        }
+    })
 
+    validStickers.push(...(await Promise.all(stickerPromises)).filter(Boolean))
     if (!validStickers.length) throw new Boom('No valid stickers could be processed', { statusCode: 400 })
 
     const { stream: covStream } = await getStream(cover)
-    const coverBuffer = await toWebp(await toBuffer(covStream))
-
-    const processBatch = async (batch, batchIdx) => {
+    const coverBuffer = await toBuffer(covStream)
+    let coverWebpBuffer
+    if (isWebPBuffer(coverBuffer)) coverWebpBuffer = coverBuffer
+    else if ('sharp' in lib && lib.sharp) coverWebpBuffer = await lib.sharp.default(coverBuffer).webp().toBuffer()
+    else if ('jimp' in lib && lib.jimp) coverWebpBuffer = await lib.jimp.Jimp.read(coverBuffer).then(img => img.getBuffer('image/webp'))
+    else throw new Boom('No image processing library available for cover', { statusCode: 500 })
+
+    const processBatch = async (batch, batchIdx, totalBatches) => {
         const batchData = {}
-        batch.forEach(s => { batchData[s.fileName] = [new Uint8Array(s.buffer), { level: 6 }] })
-        const trayFile = `${packId_}_${batchIdx}.webp`
-        batchData[trayFile] = [new Uint8Array(coverBuffer), { level: 6 }]
-        const zipBuf = await new Promise((resolve, reject) => zip(batchData, { level: 6, memLevel: 9 }, (err, data) => err ? reject(err) : resolve(Buffer.from(data))))
-        if (zipBuf.length > 10 * 1024 * 1024) throw new Boom(`Sticker pack batch ${batchIdx} too large`, { statusCode: 400 })
+        batch.forEach(s => { batchData[s.fileName] = [new Uint8Array(s.webpBuffer), { level: 0 }] })
+        const trayFile = totalBatches > 1 ? `${stickerPackIdValue}_batch${batchIdx}.webp` : `${stickerPackIdValue}.webp`
+        batchData[trayFile] = [new Uint8Array(coverWebpBuffer), { level: 0 }]
+
+        const zipBuf = await new Promise((resolve, reject) => zip(batchData, (err, data) => err ? reject(err) : resolve(Buffer.from(data))))
+
         const upload = await encryptedStream(zipBuf, 'sticker-pack', { logger: options.logger, opts: options.options })
-        const uploadRes = await options.upload(upload.encFilePath || upload.encBuffer, { fileEncSha256B64: upload.fileEncSha256.toString('base64'), mediaType: 'sticker-pack', timeoutMs: options.mediaUploadTimeoutMs || 300000 })
-        await upload.cleanup?.()
+        const uploadRes = await options.upload(upload.encFilePath || upload.encBuffer, { fileEncSha256B64: upload.fileEncSha256.toString('base64'), mediaType: 'sticker-pack', timeoutMs: options.mediaUploadTimeoutMs })
+        if (upload.encFilePath) await fs.unlink(upload.encFilePath).catch(() => { })
 
         let thumbRes = null
         try {
             let thumbBuf
-            if ('sharp' in lib && lib.sharp) thumbBuf = await lib.sharp.default(coverBuffer).resize(252, 252, { fit: 'cover' }).jpeg({ quality: 80 }).toBuffer()
+            if ('sharp' in lib && lib.sharp) thumbBuf = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer()
             else if ('jimp' in lib && lib.jimp) thumbBuf = await lib.jimp.Jimp.read(coverBuffer).then(img => img.resize({ w: 252, h: 252 }).getBuffer('image/jpeg'))
             if (thumbBuf?.length) {
                 const thumbUpload = await encryptedStream(thumbBuf, 'thumbnail-sticker-pack', { logger: options.logger, opts: options.options, mediaKey: upload.mediaKey })
-                thumbRes = await options.upload(thumbUpload.encFilePath || thumbUpload.encBuffer, { fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'), mediaType: 'thumbnail-sticker-pack', timeoutMs: options.mediaUploadTimeoutMs || 60000 })
-                await thumbUpload.cleanup?.()
+                thumbRes = await options.upload(thumbUpload.encFilePath || thumbUpload.encBuffer, { fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'), mediaType: 'thumbnail-sticker-pack', timeoutMs: options.mediaUploadTimeoutMs })
+                if (thumbUpload.encFilePath) await fs.unlink(thumbUpload.encFilePath).catch(() => { })
                 thumbRes._buf = thumbBuf; thumbRes._enc = thumbUpload
             }
         } catch (e) { options.logger?.warn({ err: e }, 'failed generating sticker pack thumbnail') }
 
         return {
-            name: batchIdx > 0 ? `${name} (${batchIdx + 1})` : name, publisher, packDescription: description,
-            stickerPackId: batchIdx > 0 ? `${packId_}_${batchIdx}` : packId_,
-            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+            name: totalBatches > 1 ? `${name} (${batchIdx + 1}/${totalBatches})` : name,
+            publisher, packDescription: description,
+            stickerPackId: totalBatches > 1 ? `${stickerPackIdValue}_${batchIdx}` : stickerPackIdValue,
+            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
             stickerPackSize: zipBuf.length,
             stickers: batch.map(s => ({ fileName: s.fileName, mimetype: s.mimetype, isAnimated: s.isAnimated, isLottie: s.isLottie, emojis: s.emojis, accessibilityLabel: s.accessibilityLabel })),
             fileSha256: upload.fileSha256, fileEncSha256: upload.fileEncSha256, mediaKey: upload.mediaKey,
@@ -543,13 +564,14 @@ export const prepareStickerPackMessage = async (stickerPack, options) => {
         }
     }
 
-    if (validStickers.length > 60) {
+    if (validStickers.length > MAX_STICKERS_PER_PACK) {
         const batches = []
-        for (let i = 0; i < validStickers.length; i += 60) batches.push(validStickers.slice(i, i + 60))
-        const results = await Promise.all(batches.map((b, i) => processBatch(b, i)))
+        for (let i = 0; i < validStickers.length; i += MAX_STICKERS_PER_PACK) batches.push(validStickers.slice(i, i + MAX_STICKERS_PER_PACK))
+        const results = []
+        for (let i = 0; i < batches.length; i++) results.push(await processBatch(batches[i], i, batches.length))
         return { stickerPackMessage: results, isBatched: true, batchCount: batches.length }
     }
-    return { stickerPackMessage: await processBatch(validStickers, 0), isBatched: false }
+    return { stickerPackMessage: await processBatch(validStickers, 0, 1), isBatched: false }
 }
 
 // ─── MESSAGE BUILDERS ─────────────────────────────────────────────────────────
@@ -562,18 +584,21 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     if (quoted && !isJidNewsletter(jid)) {
         const participant = quoted.key.fromMe ? userJid : (quoted.participant || quoted.key.participant || quoted.key.remoteJid)
         const normalizedQuoted = normalizeMessageContent(quoted.message)
-        const quotedType = getContentType(normalizedQuoted)
-        const quotedMsg = proto.Message.fromObject({ [quotedType]: normalizedQuoted[quotedType] })
-        const quotedContent = quotedMsg[quotedType]
-        if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) delete quotedContent.contextInfo
-        const contextInfo = (innerMessage[key]?.contextInfo) || {}
-        contextInfo.participant = jidNormalizedUser(participant)
-        contextInfo.stanzaId = quoted.key.id
-        contextInfo.quotedMessage = quotedMsg
-        if (jid !== quoted.key.remoteJid) contextInfo.remoteJid = quoted.key.remoteJid
-        if (innerMessage[key]) innerMessage[key].contextInfo = contextInfo
+        if (!normalizedQuoted) {
+            // stub message with no content — skip quoted context
+        } else {
+            const quotedType = getContentType(normalizedQuoted)
+            const quotedMsg = proto.Message.fromObject({ [quotedType]: normalizedQuoted[quotedType] })
+            const quotedContent = quotedMsg[quotedType]
+            if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) delete quotedContent.contextInfo
+            const contextInfo = (innerMessage[key]?.contextInfo) || {}
+            contextInfo.participant = jidNormalizedUser(participant)
+            contextInfo.stanzaId = quoted.key.id
+            contextInfo.quotedMessage = quotedMsg
+            if (jid !== quoted.key.remoteJid) contextInfo.remoteJid = quoted.key.remoteJid
+            if (innerMessage[key]) innerMessage[key].contextInfo = contextInfo
+        }
     }
-
     if (options?.ephemeralExpiration && key !== 'protocolMessage' && key !== 'ephemeralMessage' && !isJidNewsletter(jid)) {
         innerMessage[key].contextInfo = { ...(innerMessage[key].contextInfo || {}), expiration: options.ephemeralExpiration || WA_DEFAULT_EPHEMERAL }
     }
@@ -680,7 +705,7 @@ export const downloadMediaMessage = async (message, type, options, ctx) => {
 
 export const assertMediaContent = (content) => {
     content = extractMessageContent(content)
-    const mediaContent = content?.documentMessage || content?.imageMessage || content?.videoMessage || content?.audioMessage || content?.stickerMessage
+    const mediaContent = content?.documentMessage || content?.imageMessage || content?.videoMessage || content?.audioMessage || content?.stickerMessage || content?.stickerPackMessage
     if (!mediaContent) throw new Boom('given message is not a media message', { statusCode: 400, data: content })
     return mediaContent
 }