@elrayyxml/baileys 1.0.6 → 1.0.7

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,12 @@
+declare class d {
+    salt: string;
+    constructor(e: string);
+    add(e: any, t: any): any;
+    subtract(e: any, t: any): any;
+    subtractThenAdd(e: any, t: any, r: any): any;
+    _addSingle(e: any, t: any): Promise<ArrayBuffer>;
+    _subtractSingle(e: any, t: any): Promise<ArrayBuffer>;
+    performPointwiseWithOverflow(e: any, t: any, r: any): ArrayBuffer;
+}
+export declare const LT_HASH_ANTI_TAMPERING: d;
+export {};

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,7 @@
+export declare const makeMutex: () => {
+    mutex<T>(code: () => Promise<T> | T): Promise<T>;
+};
+export type Mutex = ReturnType<typeof makeMutex>;
+export declare const makeKeyedMutex: () => {
+    mutex<T>(key: string, task: () => Promise<T> | T): Promise<T>;
+};

package/lib/Utils/messages-media.d.ts

@@ -0,0 +1,120 @@
+import { Boom } from '@hapi/boom';
+import { AxiosRequestConfig } from 'axios';
+import { Readable, Transform } from 'stream';
+import { URL } from 'url';
+import { proto } from '../../WAProto';
+import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { ILogger } from './logger';
+export declare const hkdfInfoKey: (type: MediaType) => string;
+/** generates all the keys required to encrypt/decrypt & sign a media message */
+export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): Promise<MediaDecryptionKeyInfo>;
+export declare function uploadFile(buffer: Buffer, logger?: ILogger): Promise<string>;
+export declare function vid2jpg(videoUrl: string): Promise<string>;
+/**
+ * Originally written by Techwiz (https://github.com/techwiz37)
+ * Modified for customization and improvements
+ */
+export declare const extractVideoThumb: (videoPath: string) => Promise<Buffer<ArrayBufferLike>>;
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+    buffer: Buffer<ArrayBufferLike>;
+    original: {
+        width: number;
+        height: number;
+    };
+}>;
+export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
+    img: Buffer<ArrayBufferLike>;
+}>;
+/** gets the SHA256 of the given media message */
+export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined;
+export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>;
+/**
+  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
+ */
+export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array<ArrayBuffer> | undefined>;
+export declare const toReadable: (buffer: Buffer) => Readable;
+export declare const toBuffer: (stream: Readable) => Promise<Buffer<ArrayBuffer>>;
+export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
+    readonly stream: Readable;
+    readonly type: "buffer";
+} | {
+    readonly stream: Readable;
+    readonly type: "readable";
+} | {
+    readonly stream: Readable;
+    readonly type: "remote";
+} | {
+    readonly stream: import("fs").ReadStream;
+    readonly type: "file";
+}>;
+/** generates a thumbnail for a given media, if required */
+export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
+    logger?: ILogger;
+}): Promise<{
+    thumbnail: string | undefined;
+    originalImageDimensions: {
+        width: number;
+        height: number;
+    } | undefined;
+}>;
+export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
+    isStream?: true;
+}) => Promise<Readable>;
+type EncryptedStreamOptions = {
+    saveOriginalFileIfRequired?: boolean;
+    logger?: ILogger;
+    opts?: AxiosRequestConfig;
+};
+export declare const prepareStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: undefined;
+    encWriteStream: Buffer<ArrayBuffer>;
+    fileLength: number;
+    fileSha256: Buffer<ArrayBufferLike>;
+    fileEncSha256: undefined;
+    bodyPath: string | undefined;
+    didSaveToTmpPath: boolean;
+}>;
+export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: Buffer<ArrayBufferLike>;
+    encWriteStream: Readable;
+    bodyPath: string | undefined;
+    mac: Buffer<ArrayBuffer>;
+    fileEncSha256: Buffer<ArrayBufferLike>;
+    fileSha256: Buffer<ArrayBufferLike>;
+    fileLength: number;
+    didSaveToTmpPath: boolean;
+}>;
+export type MediaDownloadOptions = {
+    startByte?: number;
+    endByte?: number;
+    options?: AxiosRequestConfig<any>;
+};
+export declare const getUrlFromDirectPath: (directPath: string) => string;
+export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>;
+/**
+ * Decrypts and downloads an AES256-CBC encrypted file given the keys.
+ * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
+ * */
+export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>;
+export declare function extensionForMediaMessage(message: WAMessageContent): string;
+export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction;
+/**
+ * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
+ */
+export declare const encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => Promise<BinaryNode>;
+export declare const decodeMediaRetryNode: (node: BinaryNode) => {
+    key: import("../Types").WAMessageKey;
+    media?: {
+        ciphertext: Uint8Array;
+        iv: Uint8Array;
+    };
+    error?: Boom;
+};
+export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
+    ciphertext: Uint8Array;
+    iv: Uint8Array;
+}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>;
+export declare const getStatusCodeForMediaRetry: (code: number) => any;
+export {};

package/lib/Utils/messages.d.ts

@@ -0,0 +1,75 @@
+import { type Transform } from 'stream';
+import { proto } from '../../WAProto';
+import { ILogger } from './logger';
+import { AnyMediaMessageContent, AnyMessageContent, MediaGenerationOptions, MessageContentGenerationOptions, MessageGenerationOptions, MessageGenerationOptionsFromContent, MessageUserReceipt, WAMessage, WAMessageContent, WAProto } from '../Types';
+import { MediaDownloadOptions } from './messages-media';
+/**
+ * Uses a regex to test whether the string contains a URL, and returns the URL if it does.
+ * @param text eg. hello https://google.com
+ * @returns the URL, eg. https://google.com
+ */
+export declare const extractUrlFromText: (text: string) => string | undefined;
+export declare const generateLinkPreviewIfRequired: (text: string, getUrlInfo: MessageGenerationOptions["getUrlInfo"], logger: MessageGenerationOptions["logger"]) => Promise<import("../Types").WAUrlInfo | undefined>;
+export declare const prepareWAMessageMedia: (message: AnyMediaMessageContent, options: MediaGenerationOptions) => Promise<proto.Message>;
+export declare const prepareDisappearingMessageSettingContent: (ephemeralExpiration?: number) => proto.Message;
+/**
+ * Generate forwarded message content like WA does
+ * @param message the message to forward
+ * @param options.forceForward will show the message as forwarded even if it is from you
+ */
+export declare const generateForwardMessageContent: (message: WAMessage, forceForward?: boolean) => proto.IMessage;
+export declare const generateWAMessageContent: (message: AnyMessageContent, options: MessageContentGenerationOptions) => Promise<proto.Message>;
+export declare const generateWAMessageFromContent: (jid: string, message: WAMessageContent, options: MessageGenerationOptionsFromContent) => proto.WebMessageInfo;
+export declare const generateWAMessage: (jid: string, content: AnyMessageContent, options: MessageGenerationOptions) => Promise<proto.WebMessageInfo>;
+/** Get the key to access the true type of content */
+export declare const getContentType: (content: WAProto.IMessage | undefined) => keyof proto.IMessage | undefined;
+/**
+ * Normalizes ephemeral, view once messages to regular message content
+ * Eg. image messages in ephemeral messages, in view once messages etc.
+ * @param content
+ * @returns
+ */
+export declare const normalizeMessageContent: (content: WAMessageContent | null | undefined) => WAMessageContent | undefined;
+/**
+ * Extract the true message content from a message
+ * Eg. extracts the inner message from a disappearing message/view once message
+ */
+export declare const extractMessageContent: (content: WAMessageContent | undefined | null) => WAMessageContent | undefined;
+/**
+ * Returns the device predicted by message ID
+ */
+export declare const getDevice: (id: string) => "web" | "unknown" | "android" | "ios" | "desktop";
+/** Upserts a receipt in the message */
+export declare const updateMessageWithReceipt: (msg: Pick<WAMessage, "userReceipt">, receipt: MessageUserReceipt) => void;
+/** Update the message with a new reaction */
+export declare const updateMessageWithReaction: (msg: Pick<WAMessage, "reactions">, reaction: proto.IReaction) => void;
+/** Update the message with a new poll update */
+export declare const updateMessageWithPollUpdate: (msg: Pick<WAMessage, "pollUpdates">, update: proto.IPollUpdate) => void;
+type VoteAggregation = {
+    name: string;
+    voters: string[];
+};
+/**
+ * Aggregates all poll updates in a poll.
+ * @param msg the poll creation message
+ * @param meId your jid
+ * @returns A list of options & their voters
+ */
+export declare function getAggregateVotesInPollMessage({ message, pollUpdates }: Pick<WAMessage, 'pollUpdates' | 'message'>, meId?: string): VoteAggregation[];
+/** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
+export declare const aggregateMessageKeysNotFromMe: (keys: proto.IMessageKey[]) => {
+    jid: string;
+    participant: string | undefined;
+    messageIds: string[];
+}[];
+type DownloadMediaMessageContext = {
+    reuploadRequest: (msg: WAMessage) => Promise<WAMessage>;
+    logger: ILogger;
+};
+/**
+ * Downloads the given message. Throws an error if it's not a media message
+ */
+export declare const downloadMediaMessage: <Type extends "buffer" | "stream">(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Transform>;
+/** Checks whether the given message is a media message; if it is returns the inner content */
+export declare const assertMediaContent: (content: proto.IMessage | null | undefined) => proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
+export {};

package/lib/Utils/messages.js

@@ -16,6 +16,7 @@ const WABinary_1 = require("../WABinary");
 const crypto_2 = require("./crypto");
 const generics_1 = require("./generics");
 const messages_media_1 = require("./messages-media");
+const fflate_1 = require("fflate");
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -79,38 +80,6 @@ const prepareWAMessageMedia = async (message, options) => {
     }
     const uploadData = {
         ...message,
-        ...(message.annotations ? {
-            annotations: message.annotations
-        } : {
-            annotations: [
-                {
-                    polygonVertices: [
-                        {
-                            x: 60.71664810180664,
-                            y: -36.39784622192383
-                        },
-                        {
-                            x: -16.710189819335938,
-                            y: 49.263675689697266
-                        },
-                        {
-                            x: -56.585853576660156,
-                            y: 37.85963439941406
-                        },
-                        {
-                            x: 20.840980529785156,
-                            y: -47.80188751220703
-                        }
-                    ],
-                    newsletter: {
-                        newsletterJid: "120363402530588049@newsletter",
-                        serverMessageId: 0,
-                        newsletterName: "elrayyxml notifier 🫟",
-                        contentType: "UPDATE",
-                    }
-                }
-            ]
-        }),
         media: message[mediaType]
     };
     delete uploadData[mediaType];
@@ -321,7 +290,7 @@ exports.generateForwardMessageContent = generateForwardMessageContent;
 const generateWAMessageContent = async (message, options) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     var _p, _q;
-    let m = {};
+    let m = {};    
     if ('text' in message) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
@@ -533,8 +502,8 @@ const generateWAMessageContent = async (message, options) => {
         m.messageContextInfo = {
             // encKey
             messageSecret: message.poll.messageSecret || (0, crypto_1.randomBytes)(32),
-        };
-        const pollCreationMessage = {
+            };
+            const pollCreationMessage = {
             name: message.poll.name,
             selectableOptionsCount: message.poll.selectableCount,
             options: message.poll.values.map(optionName => ({ optionName })),
@@ -554,6 +523,113 @@ const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    else if ('stickerPack' in message) {
+    const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
+    const { Readable } = require('stream');
+    const Jimp = require('jimp');
+    const stickerData = {};
+    const stickerPackId = packId || (0, generics_1.generateMessageID)();
+    const trayIconFileName = `${stickerPackId}.webp`;
+
+    const stickerPromises = stickers.map(async (s, i) => {
+        const { stream } = await (0, messages_media_1.getStream)(s.sticker);
+        const buffer = await (0, messages_media_1.toBuffer)(stream);
+        const hash = (0, crypto_2.sha256)(buffer).toString('base64url');
+        const fileName = `${i.toString().padStart(2, '0')}_${hash}.webp`;
+        stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }];
+        return {
+            fileName,
+            mimetype: 'image/webp',
+            isAnimated: s.isAnimated || false,
+            isLottie: s.isLottie || false,
+            emojis: s.emojis || [],
+            accessibilityLabel: s.accessibilityLabel || ''
+        };
+    });
+
+    const stickerMetadata = await Promise.all(stickerPromises);
+
+    const coverBuffer = await (0, messages_media_1.toBuffer)((await (0, messages_media_1.getStream)(cover)).stream);
+    stickerData[trayIconFileName] = [new Uint8Array(coverBuffer), { level: 0 }];
+
+    const zipBuffer = await new Promise((resolve, reject) => {
+        (0, fflate_1.zip)(stickerData, (err, data) => {
+            if (err) reject(err);
+            else resolve(Buffer.from(data));
+        });
+    });
+
+    const stickerPackUpload = await (0, messages_media_1.encryptedStream)(
+        { stream: Readable.from(zipBuffer) },
+        'sticker-pack', {
+            logger: options.logger,
+            opts: options.options
+        }
+    );
+
+    const stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
+        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+        mediaType: 'sticker-pack',
+        timeoutMs: options.mediaUploadTimeoutMs
+    });
+
+    let thumbnailDirectPath, thumbnailSha256, thumbnailEncSha256, imageDataHash;
+
+    try {
+        const jimpImage = await Jimp.read(coverBuffer);
+        const thumbnailBuffer = await jimpImage.resize(252, 252).getBufferAsync(Jimp.MIME_JPEG);
+
+        const thumbUpload = await (0, messages_media_1.encryptedStream)(
+            { stream: Readable.from(thumbnailBuffer) },
+            'thumbnail-sticker-pack', {
+                logger: options.logger,
+                opts: options.options,
+                mediaKey: stickerPackUpload.mediaKey
+            }
+        );
+
+        const thumbUploadResult = await options.upload(thumbUpload.encWriteStream, {
+            fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+            mediaType: 'thumbnail-sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+
+        thumbnailDirectPath = thumbUploadResult.directPath;
+        thumbnailSha256 = thumbUpload.fileSha256;
+        thumbnailEncSha256 = thumbUpload.fileEncSha256;
+        imageDataHash = (0, crypto_2.sha256)(thumbnailBuffer).toString('base64');
+    } catch (e) {
+        options.logger?.warn?.(`Thumbnail generation failed: ${e}`);
+    }
+
+    m.stickerPackMessage = {
+        name: name,
+        publisher: publisher,
+        stickerPackId: stickerPackId,
+        packDescription: description,
+        stickerPackOrigin: WAProto_1.proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+        stickerPackSize: zipBuffer.length,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: zipBuffer.length,
+        mediaKeyTimestamp: (0, generics_1.unixTimestampSeconds)(),
+        trayIconFileName: trayIconFileName,
+        imageDataHash,
+        thumbnailDirectPath,
+        thumbnailSha256,
+        thumbnailEncSha256,
+        thumbnailHeight: 252,
+        thumbnailWidth: 252
+    };
+
+    m.stickerPackMessage.contextInfo = {
+        ...(message.contextInfo || {}),
+        ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
     else if ('event' in message) {
         m.eventMessage = {};
         const startTime = Math.floor(message.event.startDate.getTime() / 1000);
@@ -699,6 +775,29 @@ const generateWAMessageContent = async (message, options) => {
         };
         m = { listMessage };
     }
+    if ('productList' in message && !!message.productList) {
+        const thumbnail = message.thumbnail ? await (0, messages_media_1.generateThumbnail)(message.thumbnail, 'image') : null;
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            productListInfo: {
+                productSections: message.productList,
+                headerImage: {
+                    productId: message.productList[0].products[0].productId,
+                    jpegThumbnail: (thumbnail === null || thumbnail === void 0 ? void 0 : thumbnail.thumbnail) || null
+                },
+                businessOwnerJid: message.businessOwnerJid
+            },
+            listType: WAProto_1.proto.Message.ListMessage.ListType.PRODUCT_LIST
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { listMessage };
+    }
     if ('interactiveButtons' in message && !!message.interactiveButtons) {
         const interactiveMessage = {
             nativeFlowMessage: Types_1.WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
@@ -786,9 +885,180 @@ const generateWAMessageContent = async (message, options) => {
         }
         m = { interactiveMessage };
     }
+    if ('nativeFlowMessage' in message && !!message.nativeFlowMessage) {
+        const { nativeFlowMessage } = message;
+        let paramsJson = nativeFlowMessage.messageParamsJson;
+        if (typeof paramsJson === 'object' && paramsJson !== null) {
+            paramsJson = JSON.stringify(paramsJson);
+        }
+        const interactiveMessage = {
+            nativeFlowMessage: Types_1.WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+                buttons: nativeFlowMessage.buttons,
+                messageParamsJson: paramsJson
+            })
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+        } else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+        }
+        interactiveMessage.header = {
+            title: message.title || message.header,
+            subtitle: message.subtitle,
+            hasMediaAttachment: false
+        };
+        if ('footer' in message) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        if ('contextInfo' in message && !!message.contextInfo) {
+            interactiveMessage.contextInfo = message.contextInfo;
+        }
+        if ('mentions' in message && !!message.mentions) {
+            interactiveMessage.contextInfo = { ...interactiveMessage.contextInfo, mentionedJid: message.mentions };
+        }
+        const contentKeys = Object.keys(m);
+        if (contentKeys.length > 0) {
+            const mediaType = contentKeys[0];
+            interactiveMessage.header[mediaType] = m[mediaType];
+            interactiveMessage.header.hasMediaAttachment = true;
+            if (interactiveMessage.header[mediaType].contextInfo) {
+            }
+        }
+
+        m = { interactiveMessage };
+    }
+    else if ('collection' in message && !!message.collection) {
+            const interactiveMessage = {
+               collectionMessage: {
+                 bizJid: message.collection.bizJid, 
+             id: message.collection.id, 
+             messageVersion: message?.collection?.version
+          }
+      } 
+
+      if ('text' in message) {
+              interactiveMessage.body = {
+             text: message.text
+          }, 
+          interactiveMessage.header = {
+             title: message.title,
+             subtitle: message.subtitle, 
+             hasMediaAttachment: false            
+          }
+      }
+
+      else {
+              if ('caption' in message) {
+              interactiveMessage.body = {
+              text: message.caption
+           }
+           interactiveMessage.header = {
+             title: message.title, 
+             subtitle: message.subtitle, 
+             hasMediaAttachment: message.hasMediaAttachment ? message.hasMediaAttachment : false, 
+             ...Object.assign(interactiveMessage, m)
+            }
+         }
+      } 
+
+      if ('footer' in message && !message.footer) {
+              interactiveMessage.footer = {
+             text: message.footer
+          }
+      }
+
+      interactiveMessage.contextInfo = {
+          ...(message.contextInfo || {}),
+          ...(message.mentions ? { mentionedJid: message.mentions } : {})
+      }
+
+      m = { interactiveMessage }
+    }
+    else if ('cards' in message && !!message.cards) {
+        const slides = await Promise.all(message.cards.map(async (slide) => {
+            const { image, video, product, title, body, footer, buttons } = slide
+            let header
+
+            if (product) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: product.productImage, ...options }, options)
+                header = {
+                    productMessage: {
+                        product: {
+                            ...product,
+                            productImage: imageMessage,
+                        },
+                        ...slide
+                    }
+                }
+            }
+
+            else if (image) {
+                header = await prepareWAMessageMedia({ image: image, ...options }, options)
+            }
+
+            else if (video) {
+                header = await prepareWAMessageMedia({ video: video, ...options }, options)
+            }
+
+            const msg = {
+                header: {
+                    title,
+                    hasMediaAttachment: true,
+                    ...header
+                },
+                body: {
+                    text: body
+                },
+                footer: {
+                    text: footer
+                },
+                nativeFlowMessage: {
+                    buttons,
+                }
+            }
+
+            return msg
+        }))
+
+        const interactiveMessage = {
+            carouselMessage: {
+                cards: slides
+            }
+        }
+
+        if ('text' in message) {
+                interactiveMessage.body = {
+               text: message.text
+            }, 
+            interactiveMessage.header = {
+               title: message.title,
+               subtitle: message.subtitle, 
+               hasMediaAttachment: false            
+            }
+        }
+
+        if ('footer' in message && !!message.footer) {
+                interactiveMessage.footer = {
+               text: message.footer
+            }
+        }
+
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        }
+
+        m = { interactiveMessage }
+    }
+    if ('ephemeral' in message && !!message.ephemeral) {
+        m = { ephemeralMessage: { message: m } }
+    }
     if ('viewOnce' in message && !!message.viewOnce) {
         m = { viewOnceMessage: { message: m } };
     }
+    if ('viewOnceExt' in message && !!message.viewOnceExt) {
+        m = { viewOnceMessageV2Extension: { message: m } }
+    }
     if ('mentions' in message && ((_o = message.mentions) === null || _o === void 0 ? void 0 : _o.length)) {
         const [messageType] = Object.keys(m);
         m[messageType].contextInfo = m[messageType] || {};

package/lib/Utils/noise-handler.d.ts

@@ -0,0 +1,19 @@
+import { ILogger } from './logger';
+import { proto } from '../../WAProto';
+import { KeyPair } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }: {
+    keyPair: KeyPair;
+    NOISE_HEADER: Uint8Array;
+    logger: ILogger;
+    routingInfo?: Buffer | undefined;
+}) => {
+    encrypt: (plaintext: Uint8Array) => Buffer<ArrayBuffer>;
+    decrypt: (ciphertext: Uint8Array) => Buffer<ArrayBuffer>;
+    authenticate: (data: Uint8Array) => void;
+    mixIntoKey: (data: Uint8Array) => Promise<void>;
+    finishInit: () => Promise<void>;
+    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Promise<Buffer<ArrayBuffer>>;
+    encodeFrame: (data: Buffer | Uint8Array) => Buffer<ArrayBuffer>;
+    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => Promise<void>;
+};

package/lib/Utils/process-message.d.ts

@@ -0,0 +1,42 @@
+import { AxiosRequestConfig } from 'axios';
+import { proto } from '../../WAProto';
+import { AuthenticationCreds, BaileysEventEmitter, CacheStore, SignalKeyStoreWithTransaction, SocketConfig } from '../Types';
+import { ILogger } from './logger';
+type ProcessMessageContext = {
+    shouldProcessHistoryMsg: boolean;
+    placeholderResendCache?: CacheStore;
+    creds: AuthenticationCreds;
+    keyStore: SignalKeyStoreWithTransaction;
+    ev: BaileysEventEmitter;
+    getMessage: SocketConfig['getMessage'];
+    logger?: ILogger;
+    options: AxiosRequestConfig<{}>;
+};
+/** Cleans a received message to further processing */
+export declare const cleanMessage: (message: proto.IWebMessageInfo, meId: string) => void;
+export declare const isRealMessage: (message: proto.IWebMessageInfo, meId: string) => boolean | undefined;
+export declare const shouldIncrementChatUnread: (message: proto.IWebMessageInfo) => boolean;
+/**
+ * Get the ID of the chat from the given key.
+ * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
+ */
+export declare const getChatId: ({ remoteJid, participant, fromMe }: proto.IMessageKey) => string;
+type PollContext = {
+    /** normalised jid of the person that created the poll */
+    pollCreatorJid: string;
+    /** ID of the poll creation message */
+    pollMsgId: string;
+    /** poll creation message enc key */
+    pollEncKey: Uint8Array;
+    /** jid of the person that voted */
+    voterJid: string;
+};
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
+export declare function decryptPollVote({ encPayload, encIv }: proto.Message.IPollEncValue, { pollCreatorJid, pollMsgId, pollEncKey, voterJid, }: PollContext): proto.Message.PollVoteMessage;
+declare const processMessage: (message: proto.IWebMessageInfo, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>;
+export default processMessage;