@systemzero/baileys 1.0.4 → 1.0.5

package/lib/Socket/messages-send.js

@@ -568,7 +568,7 @@ export const makeMessagesSocket = (config) => {
             if (isNewsletter) {
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
                 const bytes = encodeNewsletterMessage(patched);
-                binaryNodeContent.push({ tag: 'plaintext', attrs: {}, content: bytes });
+                binaryNodeContent.push({ tag: 'plaintext', attrs: extraAttrs, content: bytes });
                 const stanza = {
                     tag: 'message',
                     attrs: { to: jid, id: msgId, type: getMessageType(message), ...(additionalAttributes || {}) },

package/lib/Types/Message.js

@@ -1,4 +1,11 @@
 import { proto } from '../../WAProto/index.js';
+export const ButtonHeaderType = proto.Message.ButtonsMessage.HeaderType;
+export const ButtonType = proto.Message.ButtonsMessage.Button.Type;
+export const CarouselCardType = proto.Message.InteractiveMessage.CarouselMessage.CarouselCardType;
+export const ListType = proto.Message.ListMessage.ListType;
+export const ProtocolType = proto.Message.ProtocolMessage.Type;
+export const AssociationType = proto.MessageAssociation?.AssociationType;
+
 // export the WAMessage Prototypes
 export { proto as WAProto };
 export const WAMessageStubType = proto.WebMessageInfo.StubType;

package/lib/Utils/messages-media.js

@@ -13,7 +13,7 @@ import { getBinaryNodeChild, getBinaryNodeChildBuffer, jidNormalizedUser } from
 import { aesDecryptGCM, aesEncryptGCM, hkdf } from './crypto.js';
 import { generateMessageIDV2 } from './generics.js';
 const getTmpFilesDirectory = () => tmpdir();
-const getImageProcessingLibrary = async () => {
+export const getImageProcessingLibrary = async () => {
     //@ts-ignore
     const [jimp, sharp] = await Promise.all([import('jimp').catch(() => { }), import('sharp').catch(() => { })]);
     if (sharp) {
@@ -210,7 +210,8 @@ export async function getAudioWaveform(buffer, logger) {
         }
         const audioBuffer = await decoder(audioData);
         const rawData = audioBuffer.getChannelData(0); // We only need to work with one channel of data
-        const samples = 64; // Number of samples we want to have in our final data set
+        const samples = 64;
+        const minHeight = 0.05;
         const blockSize = Math.floor(rawData.length / samples); // the number of samples in each subdivision
         const filteredData = [];
         for (let i = 0; i < samples; i++) {
@@ -225,7 +226,7 @@ export async function getAudioWaveform(buffer, logger) {
         const multiplier = Math.pow(Math.max(...filteredData), -1);
         const normalizedData = filteredData.map(n => n * multiplier);
         // Generate waveform like WhatsApp
-        const waveform = new Uint8Array(normalizedData.map(n => Math.floor(100 * n)));
+        const waveform = new Uint8Array(normalizedData.map(n => Math.max(minHeight, n)).map(n => Math.floor(100 * n)));
         return waveform;
     }
     catch (e) {

package/lib/Utils/messages.js

@@ -3,17 +3,17 @@ import { randomBytes, createHash, randomUUID } from 'crypto';
 import { promises as fs } from 'fs';
 import {} from 'stream';
 import { proto } from '../../WAProto/index.js';
-import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { WAMessageStatus, WAProto } from '../Types/index.js';
-import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL, DONATE_URL, LIBRARY_NAME } from '../Defaults/index.js';
+import { WAMessageStatus, WAProto, ButtonHeaderType, ButtonType, CarouselCardType, ListType } from '../Types/index.js';
+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 } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getStream, toBuffer, getImageProcessingLibrary } from './messages-media.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
     document: 'application/pdf',
-    audio: 'audio/ogg; codecs=opus',
+    audio: 'audio/mpeg',
     sticker: 'image/webp',
     'product-catalog-image': 'image/jpeg'
 };
@@ -75,9 +75,11 @@ export const prepareWAMessageMedia = async (message, options) => {
     if (mediaType === 'document' && !uploadData.fileName) {
         uploadData.fileName = 'file';
     }
-    if (!uploadData.mimetype) {
-        uploadData.mimetype = MIMETYPE_MAP[mediaType];
-    }
+if (!uploadData.mimetype) {
+    uploadData.mimetype = MIMETYPE_MAP[mediaType];
+} else if (mediaType === 'audio' && uploadData.mimetype === 'audio/ogg; codecs=opus') {
+    uploadData.mimetype = 'audio/mpeg';
+}
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
@@ -125,6 +127,7 @@ export const prepareWAMessageMedia = async (message, options) => {
     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 requiresPlaybackSpeed = mediaType === 'audio' && uploadData.ptt === true;
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
     const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
@@ -163,6 +166,13 @@ export const prepareWAMessageMedia = async (message, options) => {
                     uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
                     logger?.debug('processed waveform');
                 }
+                if (mediaType === 'audio' && uploadData.ptt === true) {
+                   uploadData.isPlaybackSpeedEnabled = true;
+                }
+                if (requiresPlaybackSpeed) {
+                   uploadData.isPlaybackSpeedEnabled = true;
+                   logger?.debug('enabled playback speed control');
+                }
                 if (requiresAudioBackground) {
                     uploadData.backgroundArgb = await assertColor(options.backgroundColor);
                     logger?.debug('computed backgroundColor audio status');
@@ -245,6 +255,240 @@ export const generateForwardMessageContent = (message, forceForward) => {
     }
     return content;
 };
+
+
+// ── WebP helpers (para stickerPack com animadas) ──────────────────────────────
+const CONCURRENCY_LIMIT = 15;
+const isAnimatedWebP = (buffer) => {
+    if (buffer.length < 12 || buffer[0] !== 0x52 || buffer[1] !== 0x49 || buffer[2] !== 0x46 || buffer[3] !== 0x46 ||
+        buffer[8] !== 0x57 || buffer[9] !== 0x45 || buffer[10] !== 0x42 || buffer[11] !== 0x50) return false;
+    let offset = 12;
+    while (offset < buffer.length - 8) {
+        const chunkFourCC = buffer.toString('ascii', offset, offset + 4);
+        const chunkSize = buffer.readUInt32LE(offset + 4);
+        if (chunkFourCC === 'VP8X') {
+            const flagsOffset = offset + 8;
+            if (flagsOffset < buffer.length && (buffer[flagsOffset] & 0x02)) return true;
+        } else if (chunkFourCC === 'ANIM' || chunkFourCC === 'ANMF') return true;
+        offset += 8 + chunkSize + (chunkSize % 2);
+    }
+    return false;
+};
+const isWebPBuffer = (buffer) => {
+    return buffer.length >= 12 && buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46 &&
+        buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50;
+};
+
+// ── prepareStickerPackMessage (da @boruto_vk7/baileys — suporte a animadas) ──
+const prepareStickerPackMessage = async (message, options) => {
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = '@systemzero/baileys', description = '' } = message;
+    if (stickers.length > 60) throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+    if (stickers.length === 0) throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+    if (!cover) throw new Boom('Sticker pack must contain a cover', { statusCode: 400 });
+    const logger = options.logger;
+    const lib = await getImageProcessingLibrary();
+    const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
+    const hasImage = 'image' in lib && !!lib.image?.Transformer;
+    const hasJimp  = 'jimp' in lib && !!lib.jimp?.Jimp;
+    const stickerPackIdValue = generateMessageIDV2();
+    const stickerData = {};
+    const stickerMetadata = new Array(stickers.length);
+    for (let i = 0; i < stickers.length; i += CONCURRENCY_LIMIT) {
+        const promises = [];
+        const chunkEnd = Math.min(i + CONCURRENCY_LIMIT, stickers.length);
+        for (let j = i; j < chunkEnd; j++) {
+            promises.push((async (index) => {
+                const sticker = stickers[index];
+                const { stream } = await getStream(sticker.data);
+                const buffer = await toBuffer(stream);
+                let webpBuffer, isAnimated = false;
+                if (isWebPBuffer(buffer)) {
+                    webpBuffer = buffer;
+                    isAnimated = isAnimatedWebP(buffer);
+                } else if (hasSharp) {
+                    webpBuffer = await lib.sharp.default(buffer).resize(512, 512, { fit: 'inside' }).webp({ quality: 80 }).toBuffer();
+                } else if (hasImage) {
+                    webpBuffer = await new lib.image.Transformer(buffer).resize(512, 512).webp(80);
+                } else {
+                    throw new Boom('No image processing library (sharp or @napi-rs/image) available', { statusCode: 500 });
+                }
+                if (webpBuffer.length > 1024 * 1024) throw new Boom(`Sticker at index ${index} exceeds 1MB limit`, { statusCode: 400 });
+                const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+                const fileName = `${hash}.webp`;
+                stickerData[fileName] = webpBuffer;
+                stickerMetadata[index] = {
+                    fileName, mimetype: 'image/webp', isAnimated,
+                    emojis: sticker.emojis || ['✨'],
+                    accessibilityLabel: sticker.accessibilityLabel || ''
+                };
+            })(j));
+        }
+        await Promise.all(promises);
+    }
+    const trayIconFileName = `${stickerPackIdValue}.webp`;
+    const { stream: coverStream } = await getStream(cover);
+    const coverBuffer = await toBuffer(coverStream);
+    let coverWebpBuffer;
+    if (isWebPBuffer(coverBuffer)) {
+        coverWebpBuffer = coverBuffer;
+    } else if (hasSharp) {
+        coverWebpBuffer = await lib.sharp.default(coverBuffer).resize(512, 512, { fit: 'inside' }).webp({ quality: 80 }).toBuffer();
+    } else if (hasImage) {
+        coverWebpBuffer = await new lib.image.Transformer(coverBuffer).resize(512, 512).webp(80);
+    } else {
+        throw new Boom('No image processing library available for cover', { statusCode: 500 });
+    }
+    stickerData[trayIconFileName] = coverWebpBuffer;
+    // Monta o ZIP usando _createZip da sz (sem fflate)
+    const zipBuffer = _createZip(Object.entries(stickerData).map(([name, data]) => ({ name, data })));
+    const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', { logger });
+    let stickerPackUploadResult;
+    try {
+        stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+    } finally {
+        fs.unlink(stickerPackUpload.encFilePath).catch(() => {});
+    }
+    const obj = {
+        name, publisher, packDescription: description,
+        stickerPackId: stickerPackIdValue,
+        stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+        stickerPackSize: zipBuffer.length,
+        stickers: stickerMetadata,
+        fileSha256:        stickerPackUpload.fileSha256,
+        fileEncSha256:     stickerPackUpload.fileEncSha256,
+        mediaKey:          stickerPackUpload.mediaKey,
+        directPath:        stickerPackUploadResult.directPath,
+        fileLength:        stickerPackUpload.fileLength,
+        mediaKeyTimestamp: unixTimestampSeconds(),
+        trayIconFileName
+    };
+    // Gerar thumbnail
+    try {
+        let thumbnailBuffer;
+        if (hasSharp) {
+            thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+        } else if (hasImage) {
+            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
+        } else if (hasJimp) {
+            const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
+            thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
+        }
+        if (thumbnailBuffer?.length > 0) {
+            const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', { logger, mediaKey: stickerPackUpload.mediaKey });
+            let thumbResult;
+            try {
+                thumbResult = await options.upload(thumbUpload.encFilePath, {
+                    fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                    mediaType: 'thumbnail-sticker-pack',
+                    timeoutMs: options.mediaUploadTimeoutMs
+                });
+            } finally {
+                fs.unlink(thumbUpload.encFilePath).catch(() => {});
+            }
+            Object.assign(obj, {
+                thumbnailDirectPath: thumbResult.directPath,
+                thumbnailSha256:     thumbUpload.fileSha256,
+                thumbnailEncSha256:  thumbUpload.fileEncSha256,
+                thumbnailHeight:     252,
+                thumbnailWidth:      252,
+                imageDataHash:       sha256(thumbnailBuffer).toString('base64')
+            });
+        }
+    } catch(e) {
+        logger?.warn('Thumbnail generation failed: ' + e.message);
+    }
+    return WAProto.Message.StickerPackMessage.fromObject(obj);
+};
+// ── Helpers adicionados da @boruto_vk7/baileys ──────────────────────────────
+export const hasNonNullishProperty = (message, key) => {
+    return message != null &&
+        typeof message === 'object' &&
+        key in message &&
+        message[key] != null;
+};
+export const hasOptionalProperty = (obj, key) => {
+    return obj != null &&
+        typeof obj === 'object' &&
+        key in obj &&
+        obj[key] != null;
+};
+export const hasValidAlbumMedia = (message) => {
+    return !!(message.imageMessage || message.videoMessage);
+};
+export const hasValidInteractiveHeader = (message) => {
+    return !!(message.imageMessage ||
+        message.videoMessage ||
+        message.documentMessage ||
+        message.productMessage ||
+        message.locationMessage);
+};
+export const hasValidCarouselHeader = (message) => {
+    return !!(message.imageMessage ||
+        message.videoMessage ||
+        message.productMessage);
+};
+// prepareNativeFlowButtons — versão completa da @boruto_vk7/baileys
+const prepareNativeFlowButtons = (message) => {
+    const buttons = message.nativeFlow;
+    const isButtonsFieldArray = Array.isArray(buttons);
+    const correctedField = isButtonsFieldArray ? buttons : (buttons?.buttons || []);
+    const messageParamsJson = {};
+    if (hasOptionalProperty(message, 'offerText') && !!message.offerText) {
+        Object.assign(messageParamsJson, {
+            limited_time_offer: {
+                text: message.offerText || '@systemzero/baileys',
+                url: message.offerUrl || 'https://systemzone.store',
+                copy_code: message.offerCode,
+                expiration_time: message.offerExpiration
+            }
+        });
+    }
+    if (hasOptionalProperty(message, 'optionText') && !!message.optionText) {
+        Object.assign(messageParamsJson, {
+            bottom_sheet: {
+                in_thread_buttons_limit: 1,
+                divider_indices: Array.from({ length: correctedField.length }, (_, i) => i),
+                list_title: message.optionTitle || '📄 Select Options',
+                button_title: message.optionText
+            }
+        });
+    }
+    return {
+        buttons: correctedField.map(button => {
+            const buttonText = button.text || button.buttonText;
+            const buttonIcon = button.icon?.toUpperCase();
+            if (hasOptionalProperty(button, 'id') && !!button.id) {
+                return { name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: buttonText || '👉🏻 Click', id: button.id, icon: buttonIcon }) };
+            } else if (hasOptionalProperty(button, 'copy') && !!button.copy) {
+                return { name: 'cta_copy', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📋 Copy', copy_code: button.copy, icon: buttonIcon }) };
+            } else if (hasOptionalProperty(button, 'url') && !!button.url) {
+                return { name: 'cta_url', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🌐 Visit', url: button.url, merchant_url: button.url, webview_interaction: button.useWebview, icon: buttonIcon }) };
+            } else if (hasOptionalProperty(button, 'call') && !!button.call) {
+                return { name: 'cta_call', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📞 Call', phone_number: button.call, icon: buttonIcon }) };
+            } else if (hasOptionalProperty(button, 'sections') && !!button.sections) {
+                return { name: 'single_select', buttonParamsJson: JSON.stringify({ title: buttonText || '📋 Select', sections: button.sections, icon: buttonIcon }) };
+            }
+            return button;
+        }),
+        messageParamsJson: JSON.stringify(messageParamsJson)
+    };
+};
+// prepareProductMessage — monta productMessage
+const prepareProductMessage = async (message, options) => {
+    const { imageMessage } = await prepareWAMessageMedia({ image: message.product?.productImage || message.image }, options);
+    return {
+        product: {
+            productImage: imageMessage,
+            ...message.product
+        },
+        businessOwnerJid: message.businessOwnerJid || '0@s.whatsapp.net'
+    };
+};
+// ── Fim dos helpers ──────────────────────────────────────────────────────────
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
@@ -447,9 +691,288 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
+
+    // ── NOVOS TIPOS (@boruto_vk7/baileys) ────────────────────────────────────
+    else if (hasNonNullishProperty(message, 'keep')) {
+        m.keepInChatMessage = {};
+        m.keepInChatMessage.key = message.keep;
+        m.keepInChatMessage.keepType = message.type;
+        m.keepInChatMessage.timestampMs = Date.now();
+    }
+    else if (hasNonNullishProperty(message, 'flowReply')) {
+        m.interactiveResponseMessage = {
+            body: {
+                format: message.flowReply.format || proto.Message.InteractiveResponseMessage.Body.Format.DEFAULT,
+                text: message.flowReply.text
+            },
+            nativeFlowResponseMessage: {
+                name: message.flowReply.name,
+                paramsJson: message.flowReply.paramsJson || '{}',
+                version: message.flowReply.version || 1
+            }
+        };
+    }
+    else if (hasNonNullishProperty(message, 'pollResult')) {
+        const pollResultSnapshotMessage = {
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.votes.map(vote => ({
+                optionName: vote.name,
+                optionVoteCount: parseInt(vote.voteCount)
+            }))
+        };
+        if (message.pollResult.pollType === 1) {
+            pollResultSnapshotMessage.pollType = proto.Message.PollType.QUIZ;
+            m.pollResultSnapshotMessageV3 = pollResultSnapshotMessage;
+        } else {
+            pollResultSnapshotMessage.pollType = proto.Message.PollType.POLL;
+            m.pollResultSnapshotMessage = pollResultSnapshotMessage;
+        }
+    }
+    else if (hasNonNullishProperty(message, 'pollUpdate')) {
+        if (!message.pollUpdate.key) throw new Boom('Message key is required', { statusCode: 400 });
+        if (!message.pollUpdate.vote) throw new Boom('Encrypted vote payload is required', { statusCode: 400 });
+        m.pollUpdateMessage = {
+            metadata: message.pollUpdate.metadata,
+            pollCreationMessageKey: message.pollUpdate.key,
+            senderTimestampMs: Date.now(),
+            vote: message.pollUpdate.vote
+        };
+    }
+    else if (hasNonNullishProperty(message, 'paymentInviteServiceType')) {
+        m.paymentInviteMessage = {
+            expiryTimestamp: Date.now(),
+            serviceType: message.paymentInviteServiceType
+        };
+    }
+    else if (hasNonNullishProperty(message, 'orderText')) {
+        if (!Buffer.isBuffer(message.thumbnail)) throw new Boom('Must provide thumbnail buffer', { statusCode: 400 });
+        m.orderMessage = {
+            itemCount: 1, messageVersion: 1,
+            orderTitle: 'Order', status: proto.Message.OrderMessage.OrderStatus.INQUIRY,
+            surface: proto.Message.OrderMessage.OrderSurface.CATALOG,
+            token: generateMessageIDV2(), totalAmount1000: 1000, totalCurrencyCode: 'BRL',
+            ...message, message: message.orderText
+        };
+        delete m.orderMessage.orderText;
+    }
+    else if (hasNonNullishProperty(message, 'stickers')) {
+        m.stickerPackMessage = await prepareStickerPackMessage(message, options);
+    }
+        else if (hasNonNullishProperty(message, 'album')) {
+        if (!Array.isArray(message.album)) throw new Boom('Invalid album type. Expected an array.', { statusCode: 400 });
+        let videoCount = 0, imageCount = 0;
+        for (let i = 0; i < message.album.length; i++) {
+            if (message.album[i].video) videoCount++;
+            if (message.album[i].image) imageCount++;
+        }
+        if ((videoCount + imageCount) < 2) throw new Boom('Minimum provide 2 media to upload album message', { statusCode: 400 });
+        m.albumMessage = { expectedImageCount: imageCount, expectedVideoCount: videoCount };
+    }
+    else if (hasNonNullishProperty(message, 'requestPaymentFrom')) {
+        const requestPaymentMessage = {
+            amount: { currencyCode: 'BRL', offset: 100, value: 1 },
+            amount1000: 1000, currencyCodeIso4217: 'BRL',
+            expiryTimestamp: Date.now(), noteMessage: m,
+            requestFrom: message.requestPaymentFrom, ...message
+        };
+        delete requestPaymentMessage.requestPaymentFrom;
+        m = { requestPaymentMessage };
+    }
+    else if (hasNonNullishProperty(message, 'invoiceNote')) {
+        const attachment = m.imageMessage || m.documentMessage;
+        const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
+        const invoiceMessage = {
+            attachmentType: proto.Message.InvoiceMessage.AttachmentType[type === 'DOCUMENT' ? 'PDF' : 'IMAGE'],
+            note: message.invoiceNote
+        };
+        if (attachment) {
+            const { directPath, fileEncSha256, fileSha256, jpegThumbnail = undefined, mediaKey, mediaKeyTimestamp, mimetype } = attachment;
+            Object.assign(invoiceMessage, {
+                attachmentDirectPath: directPath, attachmentFileEncSha256: fileEncSha256,
+                attachmentFileSha256: fileSha256, attachmentJpegThumbnail: jpegThumbnail,
+                attachmentMediaKey: mediaKey, attachmentMediaKeyTimestamp: mediaKeyTimestamp,
+                attachmentMimetype: mimetype, token: generateMessageIDV2()
+            });
+        } else {
+            throw new Boom('Invalid media type for invoice message', { statusCode: 400 });
+        }
+        m = { invoiceMessage };
+    }
+
     else {
         m = await prepareWAMessageMedia(message, options);
     }
+
+    // ── NOVOS TIPOS FASE 2: buttons/sections/templateButtons/nativeFlow/cards ─
+    if (hasNonNullishProperty(message, 'buttons')) {
+        const buttonsMessage = {
+            buttons: message.buttons.map(button => {
+                const buttonText = button.text || button.buttonText;
+                if (hasOptionalProperty(button, 'sections')) {
+                    return { nativeFlowInfo: { name: 'single_select', paramsJson: JSON.stringify({ title: buttonText, sections: button.sections }) }, type: ButtonType.NATIVE_FLOW };
+                }
+                if (hasOptionalProperty(button, 'name')) {
+                    return { nativeFlowInfo: { name: button.name, paramsJson: button.paramsJson }, type: ButtonType.NATIVE_FLOW };
+                }
+                return { buttonId: button.id || button.buttonId, buttonText: typeof buttonText === 'string' ? { displayText: buttonText } : buttonText, type: button.type || ButtonType.RESPONSE };
+            })
+        };
+        if (hasOptionalProperty(message, 'text')) {
+            buttonsMessage.contentText = message.text;
+            buttonsMessage.headerType = ButtonHeaderType.EMPTY;
+        } else {
+            if (hasOptionalProperty(message, 'caption')) buttonsMessage.contentText = message.caption;
+            const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
+            buttonsMessage.headerType = ButtonHeaderType[type];
+            Object.assign(buttonsMessage, m);
+        }
+        if (hasOptionalProperty(message, 'footer')) buttonsMessage.footerText = message.footer;
+        m = { buttonsMessage };
+    }
+    else if (hasNonNullishProperty(message, 'sections')) {
+        m = { listMessage: { sections: message.sections, buttonText: message.buttonText, title: message.title, footerText: message.footer, description: message.text, listType: ListType.SINGLE_SELECT } };
+    }
+    else if (hasNonNullishProperty(message, 'templateButtons')) {
+        const hydratedTemplate = {
+            hydratedButtons: message.templateButtons.map((button, i) => {
+                const buttonText = button.text || button.buttonText;
+                if (hasOptionalProperty(button, 'id')) return { index: i, quickReplyButton: { displayText: buttonText || '👉🏻 Click', id: button.id } };
+                if (hasOptionalProperty(button, 'url')) return { index: i, urlButton: { displayText: buttonText || '🌐 Visit', url: button.url } };
+                if (hasOptionalProperty(button, 'call')) return { index: i, callButton: { displayText: buttonText || '📞 Call', phoneNumber: button.call } };
+                button.index = button.index || i;
+                return button;
+            })
+        };
+        if (hasOptionalProperty(message, 'text')) hydratedTemplate.hydratedContentText = message.text;
+        else {
+            if (hasOptionalProperty(message, 'caption')) { hydratedTemplate.hydratedTitleText = message.title; hydratedTemplate.hydratedContentText = message.caption; }
+            Object.assign(hydratedTemplate, m);
+        }
+        if (hasOptionalProperty(message, 'footer')) hydratedTemplate.hydratedFooterText = message.footer;
+        hydratedTemplate.templateId = message.id || 'template-' + Date.now();
+        m = { templateMessage: { hydratedFourRowTemplate: hydratedTemplate, hydratedTemplate } };
+    }
+    else if (hasNonNullishProperty(message, 'nativeFlow')) {
+        const interactiveMessage = { nativeFlowMessage: prepareNativeFlowButtons(message) };
+        if (hasOptionalProperty(message, 'text')) {
+            interactiveMessage.body = { text: message.text };
+        } else {
+            if (hasOptionalProperty(message, 'caption')) {
+                const isValidHeader = hasValidInteractiveHeader(m);
+                if (!isValidHeader) throw new Boom('Invalid media type for interactive message header', { statusCode: 400 });
+                interactiveMessage.header = { title: message.title || '', subtitle: message.subtitle || '', hasMediaAttachment: isValidHeader };
+                interactiveMessage.body = { text: message.caption };
+            }
+            if (hasOptionalProperty(message, 'thumbnail') && !!message.thumbnail) interactiveMessage.jpegThumbnail = message.thumbnail;
+            if (interactiveMessage.header) Object.assign(interactiveMessage.header, m);
+        }
+        if (hasOptionalProperty(message, 'audioFooter')) {
+            const { audioMessage } = await prepareWAMessageMedia({ audio: message.audioFooter }, options);
+            interactiveMessage.footer = { audioMessage, hasMediaAttachment: true };
+        } else if (hasOptionalProperty(message, 'footer')) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        m = { interactiveMessage };
+    }
+    else if (hasNonNullishProperty(message, 'cards')) {
+        const interactiveMessage = {
+            carouselMessage: {
+                cards: await Promise.all(message.cards.map(async (card) => {
+                    let carouselHeader = await prepareWAMessageMedia(card, options).catch(() => ({}));
+                    const isValidHeader = hasValidCarouselHeader(carouselHeader);
+                    if (!isValidHeader) throw new Boom('Invalid media type for carousel card', { statusCode: 400 });
+                    const carouselCard = { nativeFlowMessage: prepareNativeFlowButtons(card.nativeFlow ? card : { nativeFlow: [] }) };
+                    if (hasOptionalProperty(card, 'text')) {
+                        carouselCard.body = { text: card.text };
+                    } else {
+                        if (hasOptionalProperty(card, 'caption')) {
+                            carouselCard.header = { title: card.title || '', subtitle: card.subtitle || '', hasMediaAttachment: isValidHeader };
+                            carouselCard.body = { text: card.caption };
+                        }
+                        if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) carouselCard.jpegThumbnail = card.thumbnail;
+                        if (carouselCard.header) Object.assign(carouselCard.header, carouselHeader);
+                    }
+                    if (hasOptionalProperty(card, 'audioFooter')) {
+                        const { audioMessage } = await prepareWAMessageMedia({ audio: card.audioFooter }, options);
+                        carouselCard.footer = { audioMessage, hasMediaAttachment: true };
+                    } else if (hasOptionalProperty(card, 'footer')) {
+                        carouselCard.footer = { text: card.footer };
+                    }
+                    return carouselCard;
+                })),
+                carouselCardType: 0, messageVersion: 1
+            }
+        };
+        if (hasOptionalProperty(message, 'text')) interactiveMessage.body = { text: message.text };
+        if (hasOptionalProperty(message, 'footer')) interactiveMessage.footer = { text: message.footer };
+        m = { interactiveMessage };
+    }
+    // ── externalAdReply ───────────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'externalAdReply') && !!message.externalAdReply) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        const content = message.externalAdReply;
+        if ('thumbnail' in content && !Buffer.isBuffer(content.thumbnail)) throw new Boom('Thumbnail must be a buffer', { statusCode: 400 });
+        const externalAdReply = {
+            ...content, body: content.body, mediaType: content.mediaType || 1,
+            mediaUrl: content.url, renderLargerThumbnail: content.largeThumbnail,
+            sourceUrl: content.url, thumbnail: content.thumbnail,
+            title: content.title || 'System Zero'
+        };
+        delete externalAdReply.largeThumbnail; delete externalAdReply.url;
+        if (key && 'contextInfo' in key && !!key.contextInfo) key.contextInfo.externalAdReply = { ...key.contextInfo.externalAdReply, ...externalAdReply };
+        else if (key) key.contextInfo = { externalAdReply };
+    }
+    // ── mentionAll ────────────────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'mentionAll') && message.mentionAll) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if (key && 'contextInfo' in key) { key.contextInfo = key.contextInfo || {}; key.contextInfo.nonJidMentions = 1; }
+        else if (key) key.contextInfo = { nonJidMentions: 1 };
+    }
+    // ── groupStatus ───────────────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'groupStatus') && !!message.groupStatus) {
+        const messageType = Object.keys(m)[0];
+        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 } };
+        delete message.groupStatus;
+    }
+    // ── spoiler ───────────────────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'spoiler') && !!message.spoiler) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if (key && 'contextInfo' in key && !!key.contextInfo) key.contextInfo.isSpoiler = message.spoiler;
+        else if (key) key.contextInfo = { isSpoiler: message.spoiler };
+        m = { spoilerMessage: { message: m } };
+        delete message.spoiler;
+    }
+    // ── interactiveAsTemplate ─────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'interactiveAsTemplate') && !!message.interactiveAsTemplate) {
+        if (!m.interactiveMessage) throw new Boom('Invalid message type for template', { statusCode: 400 });
+        m = { templateMessage: { interactiveMessageTemplate: m.interactiveMessage, templateId: message.id || 'template-' + Date.now() } };
+        delete message.interactiveAsTemplate;
+    }
+    // ── ephemeral ─────────────────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'ephemeral') && !!message.ephemeral) {
+        m = { ephemeralMessage: { message: m } };
+        delete message.ephemeral;
+    }
+    // ── isLottie ──────────────────────────────────────────────────────────────
+    if (hasOptionalProperty(message, 'isLottie') && !!message.isLottie) {
+        m = { lottieStickerMessage: { message: m } };
+    }
+    // ── viewOnceV2 / viewOnceV2Extension ──────────────────────────────────────
+    else if (hasOptionalProperty(message, 'viewOnceV2') && !!message.viewOnceV2) {
+        m = { viewOnceMessageV2: { message: m } };
+        delete message.viewOnceV2;
+    }
+    else if (hasOptionalProperty(message, 'viewOnceV2Extension') && !!message.viewOnceV2Extension) {
+        m = { viewOnceMessageV2Extension: { message: m } };
+        delete message.viewOnceV2Extension;
+    }
+
     if ('viewOnce' in message && !!message.viewOnce) {
         m = { viewOnceMessage: { message: m } };
     }
@@ -813,6 +1336,8 @@ function _createZip(files) {
     eocd.writeUInt32LE(cdBuf.length, 12); eocd.writeUInt32LE(offset, 16);
     return Buffer.concat([...locals, cdBuf, eocd]);
 }
+// sendStickerPack — wrapper de compatibilidade
+// Nova API: sock.sendMessage(jid, { cover, stickers, name, publisher })
 export const sendStickerPack = async (conn, chatId, pack, options = {}) => {
     const { name = '', publisher = '', stickers = [] } = pack;
     const zipFiles = stickers.map((s, i) => {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@systemzero/baileys",
   "type": "module",
-  "version": "1.0.4",
-  "description": "System-zero baileys bot ultra",
+  "version": "1.0.5",
+  "description": "System-zero baileys bot",
   "keywords": [
     "whatsapp",
     "automation",