@systemzero/baileys 1.0.5 → 1.0.6

package/lib/Socket/messages-send.js

@@ -782,6 +782,7 @@ export const makeMessagesSocket = (config) => {
         else if (message.contactsArrayMessage) return 'contact_array';
         else if (message.liveLocationMessage) return 'livelocation';
         else if (message.stickerMessage) return 'sticker';
+        else if (message.lottieStickerMessage) return 'sticker';
         else if (message.listMessage) return 'list';
         else if (message.listResponseMessage) return 'list_response';
         else if (message.buttonsResponseMessage) return 'buttons_response';

package/lib/Utils/bad-mac-handler.js

@@ -0,0 +1,158 @@
+/**
+ * Utilitário para lidar com erros "Bad MAC", comuns em bots WhatsApp usando
+ * Baileys quando a sessão Signal de um par fica desincronizada (ex: o
+ * outro lado reinstalou o WhatsApp, trocou de aparelho, ou houve perda de
+ * mensagens na troca de chaves). Não é uma falha do bot — é esperado que
+ * aconteça ocasionalmente em qualquer cliente Signal Protocol.
+ *
+ * Este módulo fornece funções para detectar, contar e lidar graciosamente
+ * com esses erros, sem derrubar o processo do bot.
+ *
+ * @author Dev Gui (original), integrado na lib para System Zero. By Josué </>
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { errorLog, warningLog } from './logger.js';
+
+export class BadMacHandler {
+    constructor(options = {}) {
+        this.errorCount = 0;
+        this.maxRetries = options.maxRetries ?? 5;
+        this.resetInterval = options.resetInterval ?? 300000; // 5 min
+        this.lastReset = Date.now();
+        // pasta de auth configurável — por padrão segue o padrão Baileys comum
+        this.authFolder = options.authFolder ?? path.resolve(process.cwd(), 'assets', 'auth', 'baileys');
+    }
+
+    isBadMacError(error) {
+        const errorMessage = error?.message || error?.toString() || '';
+        return (
+            errorMessage.includes('Bad MAC') ||
+            errorMessage.includes('MAC verification failed') ||
+            errorMessage.includes('decryption failed')
+        );
+    }
+
+    isSessionError(error) {
+        const errorMessage = error?.message || error?.toString() || '';
+        return (
+            errorMessage.includes('Session') ||
+            errorMessage.includes('signal protocol') ||
+            errorMessage.includes('decrypt') ||
+            this.isBadMacError(error)
+        );
+    }
+
+    /**
+     * Remove arquivos de sessão Signal problemáticos, preservando SEMPRE as
+     * credenciais principais (creds.json, app-state-sync-key/version) — só
+     * descarta arquivos de sessão por par (que serão renegociados
+     * automaticamente na próxima troca de chaves).
+     */
+    clearProblematicSessionFiles() {
+        try {
+            if (!fs.existsSync(this.authFolder)) {
+                return false;
+            }
+
+            const PRESERVE_PATTERNS = ['app-state-sync-key', 'creds.json', 'app-state-sync-version'];
+            const files = fs.readdirSync(this.authFolder);
+            let removedCount = 0;
+
+            for (const file of files) {
+                const filePath = path.join(this.authFolder, file);
+                if (!fs.statSync(filePath).isFile()) continue;
+
+                const mustPreserve = PRESERVE_PATTERNS.some((pattern) => file.includes(pattern));
+                if (mustPreserve) continue;
+
+                // só remove arquivos de sessão por par (ex: session-*.json)
+                if (file.startsWith('session-') || file.includes('sender-key')) {
+                    fs.unlinkSync(filePath);
+                    removedCount++;
+                }
+            }
+
+            if (removedCount > 0) {
+                warningLog(`${removedCount} arquivo(s) de sessão problemáticos removidos. Credenciais principais preservadas.`);
+                return true;
+            }
+
+            return false;
+        } catch (error) {
+            errorLog(`Erro ao limpar arquivos de sessão: ${error.message}`);
+            return false;
+        }
+    }
+
+    incrementErrorCount() {
+        this.errorCount++;
+        errorLog(`Bad MAC error count: ${this.errorCount}/${this.maxRetries}`);
+
+        const now = Date.now();
+        if (now - this.lastReset > this.resetInterval) {
+            this.resetErrorCount();
+        }
+    }
+
+    resetErrorCount() {
+        const previousCount = this.errorCount;
+        this.errorCount = 0;
+        this.lastReset = Date.now();
+
+        if (previousCount > 0) {
+            warningLog(`Reset do contador de Bad MAC errors. Contador anterior: ${previousCount}`);
+        }
+    }
+
+    hasReachedLimit() {
+        return this.errorCount >= this.maxRetries;
+    }
+
+    /**
+     * @returns {boolean} true se o erro foi tratado (Bad MAC engolido),
+     *                     false se NÃO era Bad MAC (deve ser relançado pelo caller)
+     */
+    handleError(error, context = 'unknown') {
+        if (!this.isBadMacError(error)) {
+            return false;
+        }
+
+        errorLog(`Bad MAC error detectado em ${context}: ${error.message}`);
+        this.incrementErrorCount();
+
+        if (this.hasReachedLimit()) {
+            warningLog(`Limite de Bad MAC errors atingido (${this.maxRetries}). Considere reiniciar o bot ou limpar sessões com clearProblematicSessionFiles().`);
+            return true;
+        }
+
+        warningLog(`Ignorando Bad MAC error e continuando operação... (${this.errorCount}/${this.maxRetries})`);
+        return true;
+    }
+
+    /** Envolve uma função async — engole Bad MAC, relança qualquer outro erro. */
+    createSafeWrapper(fn, context) {
+        return async (...args) => {
+            try {
+                return await fn(...args);
+            } catch (error) {
+                if (this.handleError(error, context)) {
+                    return null;
+                }
+                throw error;
+            }
+        };
+    }
+
+    getStats() {
+        return {
+            errorCount: this.errorCount,
+            maxRetries: this.maxRetries,
+            lastReset: new Date(this.lastReset).toISOString(),
+            timeUntilReset: Math.max(0, this.resetInterval - (Date.now() - this.lastReset)),
+        };
+    }
+}
+
+export const badMacHandler = new BadMacHandler();

package/lib/Utils/get-best-version.js

@@ -0,0 +1,41 @@
+// lib/Utils/get-best-version.js
+//
+// fetchLatestWaWebVersion() e fetchLatestBaileysVersion() SEMPRE retornam um
+// objeto com `version` preenchido, mesmo quando a busca falha — nesse caso
+// devolvem isLatest:false e um valor antigo fixo embutido na lib. Checar só
+// `if (result.version)` nunca detecta a falha, porque version sempre existe.
+//
+// Este helper tenta as duas fontes, na ordem, e só aceita um resultado se
+// `isLatest === true` (ou seja, se realmente buscou fresco da rede). Só cai
+// no valor fixo antigo se AMBAS as fontes falharem de verdade.
+
+import { fetchLatestWaWebVersion } from './generics.js';
+import { fetchLatestBaileysVersion } from './generics.js';
+
+/**
+ * @param {object} [options] - passado direto pras duas funções de fetch
+ * @returns {Promise<{ version: number[], isLatest: boolean, source: string }>}
+ */
+export const getBestWaVersion = async (options = {}) => {
+    try {
+        const web = await fetchLatestWaWebVersion(options);
+        if (web?.isLatest && web?.version) {
+            return { version: web.version, isLatest: true, source: 'web.whatsapp.com' };
+        }
+    } catch {
+        // segue pra próxima fonte
+    }
+
+    try {
+        const github = await fetchLatestBaileysVersion(options);
+        if (github?.isLatest && github?.version) {
+            return { version: github.version, isLatest: true, source: 'github' };
+        }
+    } catch {
+        // segue pro fallback fixo
+    }
+
+    // as duas fontes falharam de verdade — usa o valor fixo embutido,
+    // mas avisa explicitamente que NÃO é a versão mais atual
+    return { version: [2, 3000, 1027934701], isLatest: false, source: 'fallback-fixo' };
+};

package/lib/Utils/get-name.d.ts

@@ -0,0 +1 @@
+export declare const getName: (msg: any, contactStore?: Record<string, { name?: string; notify?: string; verifiedName?: string }>) => string;

package/lib/Utils/get-name.js

@@ -0,0 +1,54 @@
+// lib/Utils/get-name.js
+// Resolve o nome do remetente com cobertura total (nunca retorna vazio).
+// Ordem de prioridade:
+//   1) Nome salvo localmente (store/contatos) — mais confiável
+//   2) verifiedName (conta business confirmada pela Meta)
+//   3) notify / pushName da própria mensagem
+//   4) Nome resolvido via cache LID -> JID (se sender for @lid)
+//   5) Número de telefone formatado (fallback final, nunca undefined)
+
+import { jidDecode, isLidUser, sharedLidPhoneCache, lidToJid } from '../WABinary/jid-utils.js';
+
+/**
+ * @param {object} msg - mensagem completa do Baileys (proto.IWebMessageInfo)
+ * @param {object} [contactStore] - opcional: { [jid]: { name, notify, verifiedName } }
+ * @returns {string} nome final, garantido não-vazio
+ */
+export const getName = (msg, contactStore) => {
+    try {
+        const key = msg?.key || {};
+        let sender = key.participant || key.remoteJid || '';
+
+        // se vier @lid, tenta resolver pro JID real (telefone) primeiro,
+        // pois o contactStore normalmente é indexado por @s.whatsapp.net
+        let resolvedSender = sender;
+        if (isLidUser(sender)) {
+            const phone = sharedLidPhoneCache.getPhoneForLid(sender) || lidToJid(sender);
+            if (phone && phone !== sender) resolvedSender = phone;
+        }
+
+        // 1) contato salvo localmente
+        const contact = contactStore?.[resolvedSender] || contactStore?.[sender];
+        if (contact?.name && contact.name.trim()) return contact.name.trim();
+
+        // 2) verifiedName (conta business)
+        if (contact?.verifiedName && contact.verifiedName.trim()) return contact.verifiedName.trim();
+
+        // 3) pushName / notify da mensagem em si
+        const pushName = msg?.pushName || contact?.notify;
+        if (pushName && pushName.trim() && pushName.trim() !== 'WhatsApp User') {
+            return pushName.trim();
+        }
+
+        // 4) fallback: número de telefone formatado a partir do JID resolvido
+        const decoded = jidDecode(resolvedSender);
+        if (decoded?.user) {
+            return `+${decoded.user}`;
+        }
+
+        // 5) último recurso absoluto — nunca undefined/empty
+        return 'Usuário desconhecido';
+    } catch {
+        return 'Usuário desconhecido';
+    }
+};

package/lib/Utils/group-status-detection.js

@@ -0,0 +1,113 @@
+/**
+ * Detecção robusta de mensagens de status-em-grupo (marcação de status no grupo).
+ *
+ * Cobre:
+ *  - groupStatusMentionMessage / groupStatusMessage / groupStatusMessageV2
+ *  - isGroupStatus: true | 1 em qualquer nível
+ *  - statusAttributions com type GROUP_STATUS / type 5 / groupStatus: true
+ *  - mensagens aninhadas em wrappers (ephemeral, viewOnce, etc)
+ *
+ * @author Dev Gui (original), integrado na lib para System Zero. By Josué </>
+ */
+
+const MAX_MESSAGE_UNWRAP_DEPTH = 5;
+const MAX_FLAG_SCAN_DEPTH = 8;
+
+const STRONG_GROUP_STATUS_MESSAGE_KEYS = new Set([
+    'groupStatusMentionMessage',
+    'groupStatusMessage',
+    'groupStatusMessageV2',
+]);
+
+const WRAPPED_MESSAGE_KEYS = [
+    'ephemeralMessage',
+    'viewOnceMessage',
+    'viewOnceMessageV2',
+    'viewOnceMessageV2Extension',
+    'documentWithCaptionMessage',
+    'statusMentionMessage',
+    'groupStatusMentionMessage',
+    'groupStatusMessage',
+    'groupStatusMessageV2',
+];
+
+export function isGroupStatusValue(value) {
+    return value === true || value === 1;
+}
+
+function canScanObject(value) {
+    return value && typeof value === 'object' && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value);
+}
+
+function hasGroupStatusAttribution(statusAttributions) {
+    if (!Array.isArray(statusAttributions)) return false;
+
+    return statusAttributions.some(
+        (sa) =>
+            canScanObject(sa) &&
+            (Boolean(sa.groupStatus) || sa.attributionData === 'groupStatus' || sa.type === 'GROUP_STATUS' || sa.type === 5)
+    );
+}
+
+function hasGroupStatusContextInfo(contextInfo) {
+    return (
+        canScanObject(contextInfo) &&
+        (isGroupStatusValue(contextInfo.isGroupStatus) || hasGroupStatusAttribution(contextInfo.statusAttributions))
+    );
+}
+
+export function hasGroupStatusFlag(value, depth = 0, seenObjects = new WeakSet()) {
+    if (!canScanObject(value) || depth > MAX_FLAG_SCAN_DEPTH || seenObjects.has(value)) {
+        return false;
+    }
+
+    seenObjects.add(value);
+
+    for (const [key, childValue] of Object.entries(value)) {
+        if (key === 'quotedMessage') continue;
+
+        if (STRONG_GROUP_STATUS_MESSAGE_KEYS.has(key) && canScanObject(childValue)) {
+            return true;
+        }
+
+        if (key === 'isGroupStatus' && isGroupStatusValue(childValue)) {
+            return true;
+        }
+
+        if (key === 'statusAttributions' && hasGroupStatusAttribution(childValue)) {
+            return true;
+        }
+
+        if (key === 'contextInfo' && hasGroupStatusContextInfo(childValue)) {
+            return true;
+        }
+
+        if (hasGroupStatusFlag(childValue, depth + 1, seenObjects)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+export function getCurrentMessageContentVariants(message, depth = 0, seenObjects = new WeakSet()) {
+    if (!canScanObject(message) || depth > MAX_MESSAGE_UNWRAP_DEPTH || seenObjects.has(message)) {
+        return [];
+    }
+
+    seenObjects.add(message);
+
+    const variants = [message];
+
+    for (const key of WRAPPED_MESSAGE_KEYS) {
+        const wrappedMessage = message[key]?.message;
+        variants.push(...getCurrentMessageContentVariants(wrappedMessage, depth + 1, seenObjects));
+    }
+
+    return variants;
+}
+
+/** Verifica se a webMessage é uma marcação de status em grupo, inclusive em wrappers ou níveis profundos. */
+export function hasGroupStatusMessage(webMessage) {
+    return getCurrentMessageContentVariants(webMessage?.message).some((message) => hasGroupStatusFlag(message));
+}

package/lib/Utils/index.js

@@ -16,4 +16,11 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
+export * from './get-name.js';
+export * from './payment-guard.js';
+export * from './payment-detection.js';
+export * from './group-status-detection.js';
+export * from './bad-mac-handler.js';
+export * from './resolve-lid-phone.js';
+export * from './get-best-version.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/logger.js

@@ -1,3 +1,6 @@
 import P from 'pino';
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+const logger = P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+export const errorLog = (msg) => logger.error(msg);
+export const warningLog = (msg) => logger.warn(msg);
+export default logger;
 //# sourceMappingURL=logger.js.map

package/lib/Utils/messages-media.js

@@ -7,12 +7,50 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { Readable, Transform } from 'stream';
 import { URL } from 'url';
+import { promisify } from 'util';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_ORIGIN, MEDIA_HKDF_KEY_MAPPING, MEDIA_PATH_MAP } from '../Defaults/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildBuffer, jidNormalizedUser } from '../WABinary/index.js';
 import { aesDecryptGCM, aesEncryptGCM, hkdf } from './crypto.js';
 import { generateMessageIDV2 } from './generics.js';
 const getTmpFilesDirectory = () => tmpdir();
+const execAsync = promisify(exec);
+
+/**
+ * Converte QUALQUER áudio de entrada pra opus/ogg mono 16kHz — o formato
+ * exato que o player de PTT do WhatsApp espera. Sem isso, marcar `ptt: true`
+ * num mp3/m4a só troca o RÓTULO do mimetype sem mudar os bytes reais, e o
+ * WhatsApp mostra "algo errado com o arquivo de áudio" ao tentar decodificar.
+ *
+ * @param {string | Buffer} input - caminho de arquivo local, URL http(s), ou Buffer já em memória
+ * @returns {Promise<string>} caminho do arquivo .ogg convertido (temporário — chame fs.unlink depois de usar)
+ */
+export async function transcodeAudioToOpus(input) {
+    const outputPath = join(getTmpFilesDirectory(), 'ptt-' + generateMessageIDV2() + '.ogg');
+    let inputPath = input;
+    let tempInputPath;
+
+    try {
+        if (Buffer.isBuffer(input)) {
+            tempInputPath = join(getTmpFilesDirectory(), 'ptt-src-' + generateMessageIDV2());
+            await fs.writeFile(tempInputPath, input);
+            inputPath = tempInputPath;
+        }
+
+        // -vn: ignora qualquer vídeo/capa embutida (mp3 com artwork, por exemplo)
+        // -ac 1 -ar 16000: mono 16kHz — espec exata do PTT nativo do WhatsApp
+        // -c:a libopus -b:a 32k: codec real opus, não só o rótulo
+        const cmd = `ffmpeg -i "${inputPath}" -y -vn -ac 1 -ar 16000 -c:a libopus -b:a 32k -f ogg "${outputPath}"`;
+        await execAsync(cmd);
+
+        return outputPath;
+    } finally {
+        if (tempInputPath) {
+            await fs.unlink(tempInputPath).catch(() => {});
+        }
+    }
+}
+
 export const getImageProcessingLibrary = async () => {
     //@ts-ignore
     const [jimp, sharp] = await Promise.all([import('jimp').catch(() => { }), import('sharp').catch(() => { })]);

package/lib/Utils/messages.js

@@ -8,7 +8,7 @@ import { WAMessageStatus, WAProto, ButtonHeaderType, ButtonType, CarouselCardTyp
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser, isLidUser, isPnUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getStream, toBuffer, getImageProcessingLibrary } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getStream, toBuffer, getImageProcessingLibrary, transcodeAudioToOpus } from './messages-media.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -77,9 +77,32 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
 if (!uploadData.mimetype) {
     uploadData.mimetype = MIMETYPE_MAP[mediaType];
-} else if (mediaType === 'audio' && uploadData.mimetype === 'audio/ogg; codecs=opus') {
-    uploadData.mimetype = 'audio/mpeg';
 }
+// ptt: true → transcodifica de verdade pra opus/ogg mono 16kHz.
+// Antes, isso só trocava o RÓTULO do mimetype sem mudar os bytes reais,
+// o que fazia o WhatsApp mostrar "algo errado com o arquivo de áudio"
+// pra qualquer entrada que não já fosse opus puro.
+//
+// IMPORTANTE: não confia no `mimetype` que o CALLER declarou (a pessoa
+// pode escrever 'audio/ogg' mesmo passando um mp3/m4a de origem) — só
+// confia na extensão real do arquivo/URL de origem.
+let pttTranscodedPath;
+if (mediaType === 'audio' && uploadData.ptt === true) {
+    const mediaUrl = typeof uploadData.media === 'string'
+        ? uploadData.media
+        : uploadData.media?.url?.toString?.() || '';
+    const sourceLooksLikeOpus = /\.(opus|ogg)(\?|$)/i.test(mediaUrl);
+
+    if (!sourceLooksLikeOpus) {
+        const sourceForTranscode = Buffer.isBuffer(uploadData.media)
+            ? uploadData.media
+            : (typeof uploadData.media === 'string' ? uploadData.media : mediaUrl);
+        pttTranscodedPath = await transcodeAudioToOpus(sourceForTranscode);
+        uploadData.media = pttTranscodedPath;
+    }
+    uploadData.mimetype = 'audio/ogg; codecs=opus';
+}
+
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
@@ -118,6 +141,10 @@ if (!uploadData.mimetype) {
         if (obj.stickerMessage) {
             obj.stickerMessage.stickerSentTs = Date.now();
         }
+        // lottie: stickerSentTs também no stickerMessage interno
+        if (obj.lottieStickerMessage?.message?.stickerMessage) {
+            obj.lottieStickerMessage.message.stickerMessage.stickerSentTs = Date.now();
+        }
         if (cacheableKey) {
             logger?.debug({ cacheableKey }, 'set cache');
             await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
@@ -126,10 +153,10 @@ if (!uploadData.mimetype) {
     }
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
-    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
+    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
     const requiresPlaybackSpeed = mediaType === 'audio' && uploadData.ptt === true;
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
-    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
+    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
     const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
@@ -188,6 +215,9 @@ if (!uploadData.mimetype) {
             if (originalFilePath) {
                 await fs.unlink(originalFilePath);
             }
+            if (pttTranscodedPath) {
+                await fs.unlink(pttTranscodedPath);
+            }
             logger?.debug('removed tmp files');
         }
         catch (error) {
@@ -472,6 +502,70 @@ const prepareNativeFlowButtons = (message) => {
             } else if (hasOptionalProperty(button, 'sections') && !!button.sections) {
                 return { name: 'single_select', buttonParamsJson: JSON.stringify({ title: buttonText || '📋 Select', sections: button.sections, icon: buttonIcon }) };
             }
+            // ── Botões estendidos (vanzxy) ──────────────────────────────────────
+            else if (hasOptionalProperty(button, 'reminder') && !!button.reminder) {
+                return { name: 'cta_reminder', buttonParamsJson: JSON.stringify({ display_text: buttonText || '⏰ Remind me', id: button.id || button.reminder, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'cancelReminder') && !!button.cancelReminder) {
+                return { name: 'cta_cancel_reminder', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🔕 Cancel reminder', id: button.id || button.cancelReminder, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'address') && !!button.address) {
+                return { name: 'address_message', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📍 Send address', id: button.id || 'address_message' }) };
+            }
+            else if (hasOptionalProperty(button, 'location') && button.location === true) {
+                return { name: 'send_location', buttonParamsJson: JSON.stringify({}) };
+            }
+            else if (hasOptionalProperty(button, 'catalog') && !!button.catalog) {
+                return { name: 'catalog_message', buttonParamsJson: JSON.stringify({ business_phone_number: button.catalog.bizJid || button.catalog, display_text: buttonText || '🛍️ View catalog', id: button.id || 'catalog_message' }) };
+            }
+            else if (hasOptionalProperty(button, 'products') && !!button.products) {
+                return { name: 'mpm', buttonParamsJson: JSON.stringify({ business_phone_number: button.bizJid || button.products.bizJid, product_ids: Array.isArray(button.products) ? button.products : button.products.ids }) };
+            }
+            else if (hasOptionalProperty(button, 'otp') && !!button.otp) {
+                return { name: 'otp_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || 'Copy code', code: button.otp }) };
+            }
+            else if (hasOptionalProperty(button, 'oneTapOtp') && !!button.oneTapOtp) {
+                return { name: 'authentication_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || 'Autofill', code: button.oneTapOtp }) };
+            }
+            else if (hasOptionalProperty(button, 'phoneNumber') && !!button.phoneNumber) {
+                return { name: 'call_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📞 Call', phone_number: button.phoneNumber }) };
+            }
+            else if (hasOptionalProperty(button, 'urlBtn') && !!button.urlBtn) {
+                return { name: 'url_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🌐 Open', url: button.urlBtn }) };
+            }
+            else if (hasOptionalProperty(button, 'card') && !!button.card) {
+                return { name: 'card_message', buttonParamsJson: JSON.stringify(button.card) };
+            }
+            else if (hasOptionalProperty(button, 'orderDetails') && !!button.orderDetails) {
+                return { name: 'order_details', buttonParamsJson: JSON.stringify(button.orderDetails) };
+            }
+            else if (hasOptionalProperty(button, 'orderStatus') && !!button.orderStatus) {
+                return { name: 'order_status', buttonParamsJson: JSON.stringify(button.orderStatus) };
+            }
+            else if (hasOptionalProperty(button, 'trackOrder') && !!button.trackOrder) {
+                return { name: 'track_order', buttonParamsJson: JSON.stringify({ id: button.id || button.trackOrder, display_text: buttonText || '🚚 Track order' }) };
+            }
+            else if (hasOptionalProperty(button, 'reorder') && !!button.reorder) {
+                return { name: 'reorder', buttonParamsJson: JSON.stringify({ id: button.id || button.reorder, display_text: buttonText || '🔁 Reorder' }) };
+            }
+            else if (hasOptionalProperty(button, 'cancelOrder') && !!button.cancelOrder) {
+                return { name: 'cancel_order', buttonParamsJson: JSON.stringify({ id: button.id || button.cancelOrder, display_text: buttonText || '❌ Cancel order' }) };
+            }
+            else if (hasOptionalProperty(button, 'clearChat') && button.clearChat === true) {
+                return { name: 'clear_chat', buttonParamsJson: JSON.stringify({}) };
+            }
+            else if (hasOptionalProperty(button, 'screen') && !!button.screen) {
+                return { name: 'navigateToScreen', buttonParamsJson: JSON.stringify({ screen_name: button.screen, data: button.data || {} }) };
+            }
+            else if (hasOptionalProperty(button, 'flow') && !!button.flow) {
+                return { name: 'flow_action', buttonParamsJson: JSON.stringify({ flow_message_version: button.flow.version || '3', flow_id: button.flow.id, flow_cta: buttonText || button.flow.cta || 'Continue', flow_action: button.flow.action || 'navigate', flow_action_payload: button.flow.actionPayload || { screen: button.flow.screen || 'WELCOME', data: button.flow.data || {} } }) };
+            }
+            else if (hasOptionalProperty(button, 'voiceCall') && !!button.voiceCall) {
+                return { name: 'voice_call', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📞 Voice call', id: button.id || button.voiceCall }) };
+            }
+            else if (hasOptionalProperty(button, 'videoCall') && !!button.videoCall) {
+                return { name: 'video_call_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🎥 Video call', id: button.id || button.videoCall }) };
+            }
             return button;
         }),
         messageParamsJson: JSON.stringify(messageParamsJson)
@@ -936,7 +1030,12 @@ export const generateWAMessageContent = async (message, options) => {
         const key = m[messageType];
         if (key && 'contextInfo' in key && !!key.contextInfo) key.contextInfo.isGroupStatus = message.groupStatus;
         else if (key) key.contextInfo = { isGroupStatus: message.groupStatus };
-        m = { groupStatusMessageV2: { message: m } };
+        // Fix: audio PTT usa groupStatusMessage (v1) — V2 causa tela preta em versões antigas do WA
+        if (messageType === 'audioMessage') {
+            m = { groupStatusMessage: { message: m } };
+        } else {
+            m = { groupStatusMessageV2: { message: m } };
+        }
         delete message.groupStatus;
     }
     // ── spoiler ───────────────────────────────────────────────────────────────
@@ -961,6 +1060,12 @@ export const generateWAMessageContent = async (message, options) => {
     }
     // ── isLottie ──────────────────────────────────────────────────────────────
     if (hasOptionalProperty(message, 'isLottie') && !!message.isLottie) {
+        // marca o stickerMessage interno com isLottie: true para o WA renderizar como premium
+        if (m.stickerMessage) {
+            m.stickerMessage.isLottie = true;
+            m.stickerMessage.isAnimated = m.stickerMessage.isAnimated ?? false;
+            m.stickerMessage.isAiSticker = false;
+        }
         m = { lottieStickerMessage: { message: m } };
     }
     // ── viewOnceV2 / viewOnceV2Extension ──────────────────────────────────────
@@ -1094,7 +1199,8 @@ export const normalizeMessageContent = (content) => {
             message?.documentWithCaptionMessage ||
             message?.viewOnceMessageV2 ||
             message?.viewOnceMessageV2Extension ||
-            message?.editedMessage);
+            message?.editedMessage ||
+            message?.lottieStickerMessage);
     }
 };
 export const extractMessageContent = (content) => {