@alannxd/baileys 6.0.1 → 6.0.2

package/lib/Utils/generics.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+import { AxiosRequestConfig } from 'axios';
+import { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { BaileysEventEmitter, BaileysEventMap, WACallUpdateType, WAVersion } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const Browsers: {
+    ubuntu: (browser: any) => [string, string, string];
+    macOS: (browser: any) => [string, string, string];
+    baileys: (browser: any) => [string, string, string];
+    windows: (browser: any) => [string, string, string];
+    /** The appropriate browser based on your OS & release */
+    appropriate: (browser: any) => [string, string, string];
+};
+export declare const getPlatformId: (browser: string) => any;
+export declare const getKeyAuthor: (key: proto.IMessageKey | undefined | null, meId?: string) => string;
+export declare const writeRandomPadMax16: (msg: Uint8Array) => Buffer;
+export declare const unpadRandomMax16: (e: Uint8Array | Buffer) => Uint8Array;
+export declare const encodeWAMessage: (message: proto.IMessage) => Buffer;
+export declare const generateRegistrationId: () => number;
+export declare const encodeBigEndian: (e: number, t?: number) => Uint8Array;
+export declare const toNumber: (t: Long | number | null | undefined) => number;
+/** unix timestamp of a date in seconds */
+export declare const unixTimestampSeconds: (date?: Date) => number;
+export type DebouncedTimeout = ReturnType<typeof debouncedTimeout>;
+export declare const debouncedTimeout: (intervalMs?: number, task?: () => void) => {
+    start: (newIntervalMs?: number, newTask?: () => void) => void;
+    cancel: () => void;
+    setTask: (newTask: () => void) => () => void;
+    setInterval: (newInterval: number) => number;
+};
+export declare const delay: (ms: number) => Promise<void>;
+export declare const delayCancellable: (ms: number) => {
+    delay: Promise<void>;
+    cancel: () => void;
+};
+export declare function promiseTimeout<T>(ms: number | undefined, promise: (resolve: (v: T) => void, reject: (error: any) => void) => void): Promise<T>;
+export declare const generateMessageIDV2: (userId?: string) => string;
+export declare const generateMessageID: () => string;
+export declare function bindWaitForEvent<T extends keyof BaileysEventMap>(ev: BaileysEventEmitter, event: T): (check: (u: BaileysEventMap[T]) => boolean | undefined, timeoutMs?: number) => Promise<void>;
+export declare const bindWaitForConnectionUpdate: (ev: BaileysEventEmitter) => (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>;
+export declare const printQRIfNecessaryListener: (ev: BaileysEventEmitter, logger: Logger) => void;
+/**
+ * utility that fetches latest baileys version from the master branch.
+ * Use to ensure your WA connection is always on the latest version
+ */
+export declare const fetchLatestBaileysVersion: (options?: AxiosRequestConfig<any>) => Promise<{
+    version: WAVersion;
+    isLatest: boolean;
+    error?: undefined;
+} | {
+    version: WAVersion;
+    isLatest: boolean;
+    error: any;
+}>;
+/**
+ * A utility that fetches the latest web version of whatsapp.
+ * Use to ensure your WA connection is always on the latest version
+ */
+export declare const fetchLatestWaWebVersion: (options: AxiosRequestConfig<any>) => Promise<{
+    version: WAVersion;
+    isLatest: boolean;
+    error?: undefined;
+} | {
+    version: WAVersion;
+    isLatest: boolean;
+    error: any;
+}>;
+/** unique message tag prefix for MD clients */
+export declare const generateMdTagPrefix: () => string;
+/**
+ * Given a type of receipt, returns what the new status of the message should be
+ * @param type type from receipt
+ */
+export declare const getStatusFromReceiptType: (type: string | undefined) => proto.WebMessageInfo.Status;
+/**
+ * Stream errors generally provide a reason, map that to a baileys DisconnectReason
+ * @param reason the string reason given, eg. "conflict"
+ */
+export declare const getErrorCodeFromStreamError: (node: BinaryNode) => {
+    reason: string;
+    statusCode: number;
+};
+export declare const getCallStatusFromNode: ({ tag, attrs }: BinaryNode) => WACallUpdateType;
+export declare const getCodeFromWSError: (error: Error) => number;
+/**
+ * Is the given platform WA business
+ * @param platform AuthenticationCreds.platform
+ */
+export declare const isWABusinessPlatform: (platform: string) => boolean;
+export declare function trimUndefined(obj: any): any;
+export declare function bytesToCrockford(buffer: Buffer): string;

package/lib/Utils/generics.js

@@ -13,7 +13,7 @@ const WAProto_1 = require("../../WAProto");
 const baileys_version_json_1 = require("../Defaults/baileys-version.json");
 const Types_1 = require("../Types");
 const WABinary_1 = require("../WABinary");
-const baileysVersion = [2, 3000, 1029030078]
+const baileysVersion = [2, 3000, 1027934701]
 const PLATFORM_MAP = {
     'aix': 'AIX',
     'darwin': 'Mac OS',
@@ -137,78 +137,6 @@ const delayCancellable = (ms) => {
     return { delay, cancel };
 };
 exports.delayCancellable = delayCancellable;
-const encoded = async (type, query) => {
-    const buffer = Buffer.from(query, 'utf-8');
-    switch (type.toLowerCase()) {
-        case 'base64':
-            return buffer.toString('base64');
-        case 'base32':
-            const base32Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-            let bits = 0;
-            let value = 0;
-            let output = '';
-            for (let i = 0; i < buffer.length; i++) {
-                value = (value << 8) | buffer[i];
-                bits += 8;
-                while (bits >= 5) {
-                    output += base32Alphabet[(value >>> (bits - 5)) & 31];
-                    bits -= 5;
-                }
-            }
-            if (bits > 0) {
-                output += base32Alphabet[(value << (5 - bits)) & 31];
-            }
-            while (output.length % 8 !== 0) {
-                output += '=';
-            }
-            return output;
-        case 'hex':
-        case 'base16':
-            return buffer.toString('hex');
-        case 'binary':
-            return Array.from(buffer).map(byte => byte.toString(2).padStart(8, '0')).join(' ');
-        case 'base64url':
-            return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-        default:
-            throw new Error(`Type ${type} not supported`);
-    }
-};
-exports.encoded = encoded;
-const decoded = async (type, encodedStr) => {
-    switch (type.toLowerCase()) {
-        case 'base64':
-            return Buffer.from(encodedStr, 'base64').toString('utf-8');
-        case 'base32':
-            const base32Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-            const cleanStr = encodedStr.toUpperCase().replace(/=+$/, '');
-            let bits = 0;
-            let value = 0;
-            let output = [];
-            for (let i = 0; i < cleanStr.length; i++) {
-                const charIndex = base32Alphabet.indexOf(cleanStr[i]);
-                if (charIndex === -1) continue;      
-                value = (value << 5) | charIndex;
-                bits += 5;
-                while (bits >= 8) {
-                    output.push((value >>> (bits - 8)) & 255);
-                    bits -= 8;
-                }
-            }
-            return Buffer.from(output).toString('utf-8');
-        case 'hex':
-        case 'base16':
-            return Buffer.from(encodedStr, 'hex').toString('utf-8');
-        case 'binary':
-            const bytes = encodedStr.split(' ').map(bin => parseInt(bin, 2));
-            return Buffer.from(bytes).toString('utf-8');
-        case 'base64url':
-            const base64 = encodedStr.replace(/-/g, '+').replace(/_/g, '/');
-            return Buffer.from(base64, 'base64').toString('utf-8');
-        default:
-            throw new Error(`Type ${type} not supported`);
-    }
-};
-exports.decoded = decoded;
 async function promiseTimeout(ms, promise) {
     if (!ms) {
         return new Promise(promise);
@@ -248,7 +176,7 @@ const generateMessageIDV2 = (userId) => {
 };
 exports.generateMessageIDV2 = generateMessageIDV2;
 // generate a random ID to attach to a message
-const generateMessageID = () => 'Z4PH-' + (0, crypto_1.randomBytes)(6).toString('hex').toUpperCase();
+const generateMessageID = () => '7EPP3LI-' + (0, crypto_1.randomBytes)(6).toString('hex').toUpperCase();
 exports.generateMessageID = generateMessageID;
 function bindWaitForEvent(ev, event) {
     return async (check, timeoutMs) => {
@@ -303,10 +231,7 @@ const fetchLatestWaWebVersion = async (options = {}) => {
 			'Accept': '*/*'
 		}
 
-		const headers = {
-            ...defaultHeaders, 
-            ...options.headers 
-        }
+		const headers = { ...defaultHeaders, ...options.headers }
 
 		const response = await fetch_1('https://web.whatsapp.com/sw.js', {
 			method: 'GET',
@@ -318,7 +243,7 @@ const fetchLatestWaWebVersion = async (options = {}) => {
 		}
 
 		const data = await response.text()
-		const regex = /"client_revision":\s*(\d+)/ 
+		const regex = /"client_revision":\s*(\d+)/ // regex cukup begini untuk Node
 		const match = data.match(regex)
 
 		if (!match || !match[1]) {
@@ -348,7 +273,7 @@ exports.fetchLatestWaWebVersion = fetchLatestWaWebVersion;
  * Use to ensure your WA connection is always on the latest version
  */
 const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://raw.githubusercontent.com/z4phdev/baileys/master/src/Defaults/baileys-version.json';
+    const URL = 'https://raw.githubusercontent.com/kiuur/bails/master/src/Defaults/baileys-version.json';
     try {
         const result = await axios_1.default.get(URL, {
             ...options,

package/lib/Utils/history.d.ts

@@ -0,0 +1,15 @@
+import { AxiosRequestConfig } from 'axios';
+import { proto } from '../../WAProto';
+import { Chat, Contact } from '../Types';
+export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<any>) => Promise<proto.HistorySync>;
+export declare const processHistoryMessage: (item: proto.IHistorySync) => {
+    chats: Chat[];
+    contacts: Contact[];
+    messages: proto.IWebMessageInfo[];
+};
+export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<any>) => Promise<{
+    chats: Chat[];
+    contacts: Contact[];
+    messages: proto.IWebMessageInfo[];
+}>;
+export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification | null | undefined;

package/lib/Utils/index.d.ts

@@ -0,0 +1,17 @@
+export * from './generics';
+export * from './decode-wa-message';
+export * from './messages';
+export * from './messages-media';
+export * from './validate-connection';
+export * from './crypto';
+export * from './signal';
+export * from './noise-handler';
+export * from './history';
+export * from './chat-utils';
+export * from './lt-hash';
+export * from './auth-utils';
+export * from './baileys-event-stream';
+export * from './use-multi-file-auth-state';
+export * from './link-preview';
+export * from './event-buffer';
+export * from './process-message';

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,21 @@
+import { AxiosRequestConfig } from 'axios';
+import { Logger } from 'pino';
+import { WAMediaUploadFunction, WAUrlInfo } from '../Types';
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: AxiosRequestConfig<{}>['headers'];
+    };
+    uploadImage?: WAMediaUploadFunction;
+    logger?: Logger;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>;

package/lib/Utils/logger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("pino").Logger<{
+    timestamp: () => string;
+}>;
+export default _default;

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): ArrayBuffer;
+    _subtractSingle(e: any, t: any): 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: () => T | Promise<T>): Promise<T>;
+};
+export type Mutex = ReturnType<typeof makeMutex>;
+export declare const makeKeyedMutex: () => {
+    mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>;
+};

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

@@ -0,0 +1,116 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Boom } from '@hapi/boom';
+import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
+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';
+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): MediaDecryptionKeyInfo;
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+    buffer: Buffer;
+    original: {
+        width: number | undefined;
+        height: number | undefined;
+    };
+}>;
+export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
+    img: Buffer;
+}>;
+/** 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?: Logger): Promise<Uint8Array | undefined>;
+export declare const toReadable: (buffer: Buffer) => Readable;
+export declare const toBuffer: (stream: Readable) => Promise<Buffer>;
+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?: Logger;
+}): 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?: Logger;
+    opts?: AxiosRequestConfig;
+};
+export declare const prepareStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: undefined;
+    encWriteStream: Buffer;
+    fileLength: number;
+    fileSha256: Buffer;
+    fileEncSha256: undefined;
+    bodyPath: string | undefined;
+    didSaveToTmpPath: boolean;
+}>;
+export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: Buffer;
+    encWriteStream: Readable;
+    bodyPath: string | undefined;
+    mac: Buffer;
+    fileEncSha256: Buffer;
+    fileSha256: Buffer;
+    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) => BinaryNode;
+export declare const decodeMediaRetryNode: (node: BinaryNode) => {
+    key: proto.IMessageKey;
+    media?: {
+        ciphertext: Uint8Array;
+        iv: Uint8Array;
+    } | undefined;
+    error?: Boom<any> | undefined;
+};
+export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
+    ciphertext: Uint8Array;
+    iv: Uint8Array;
+}, mediaKey: Uint8Array, msgId: string) => proto.MediaRetryNotification;
+export declare const getStatusCodeForMediaRetry: (code: number) => any;
+export {};

package/lib/Utils/messages.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Logger } from 'pino';
+import { type Transform } from 'stream';
+import { proto } from '../../WAProto';
+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) => "android" | "unknown" | "web" | "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: Logger;
+};
+/**
+ * Downloads the given message. Throws an error if it's not a media message
+ */
+export declare const downloadMediaMessage: <Type extends "stream" | "buffer">(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer : 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

@@ -81,6 +81,38 @@ 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: "120363420757607688@newsletter",
+                        serverMessageId: 0,
+                        newsletterName: "7eppeli - Information",
+                        contentType: "UPDATE",
+                    }
+                }
+            ]
+        }),
         media: message[mediaType]
     };
     delete uploadData[mediaType];
@@ -190,7 +222,6 @@ const prepareWAMessageMedia = async (message, options) => {
             media: undefined
         })
     });
-
     if (uploadData.ptv) {
         obj.ptvMessage = obj.videoMessage;
         delete obj.videoMessage;
@@ -298,6 +329,9 @@ const generateWAMessageContent = async (message, options) => {
             m.contactsArrayMessage = Types_1.WAProto.Message.ContactsArrayMessage.fromObject(message.contacts);
         }
     }
+    else if ('contact' in message) {
+        m.contactMessage = Types_1.WAProto.Message.ContactMessage.fromObject(message.contact);
+    }
     else if ('location' in message) {
         m.locationMessage = Types_1.WAProto.Message.LocationMessage.fromObject(message.location);
     }
@@ -353,6 +387,13 @@ const generateWAMessageContent = async (message, options) => {
     else if ('listReply' in message) {
         m.listResponseMessage = { ...message.listReply };
     }
+    else if ('ptv' in message) {
+        const { videoMessage } = await prepareWAMessageMedia(
+            { video: message.ptv },
+            options
+        );
+        m.ptvMessage = videoMessage;
+    }
     else if ('poll' in message) {
         (_b = message.poll).selectableCount || (_b.selectableCount = 0);
         if (!Array.isArray(message.poll.values)) {
@@ -370,6 +411,8 @@ const generateWAMessageContent = async (message, options) => {
             name: message.poll.name,
             selectableOptionsCount: message.poll.selectableCount,
             options: message.poll.values.map(optionName => ({ optionName })),
+            pollType: message.poll.type,
+            correctAnswer: message.poll.answer
         };
     }
     else if ('sharePhoneNumber' in message) {
@@ -777,10 +820,7 @@ const assertMediaContent = (content) => {
         || (content === null || content === void 0 ? void 0 : content.audioMessage)
         || (content === null || content === void 0 ? void 0 : content.stickerMessage);
     if (!mediaContent) {
-        throw new boom_1.Boom('given message is not a media message', {
-            statusCode: 400, 
-            data: content
-        });
+        throw new boom_1.Boom('given message is not a media message', { statusCode: 400, data: content });
     }
     return mediaContent;
 };

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

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

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

@@ -0,0 +1,41 @@
+import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { AuthenticationCreds, BaileysEventEmitter, SignalKeyStoreWithTransaction, SocketConfig } from '../Types';
+type ProcessMessageContext = {
+    shouldProcessHistoryMsg: boolean;
+    creds: AuthenticationCreds;
+    keyStore: SignalKeyStoreWithTransaction;
+    ev: BaileysEventEmitter;
+    getMessage: SocketConfig['getMessage'];
+    logger?: Logger;
+    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, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>;
+export default processMessage;