@kelvdra/baileys 1.0.3 → 1.0.4

package/lib/Utils/index.d.ts

@@ -0,0 +1,19 @@
+export * from './generics.js';
+export * from './decode-wa-message.js';
+export * from './messages.js';
+export * from './messages-media.js';
+export * from './validate-connection.js';
+export * from './crypto.js';
+export * from './signal.js';
+export * from './noise-handler.js';
+export * from './history.js';
+export * from './chat-utils.js';
+export * from './lt-hash.js';
+export * from './auth-utils.js';
+export * from './use-multi-file-auth-state.js';
+export * from './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.js';
+export * from './message-retry-manager.js';
+export * from './browser-utils.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { WAMediaUploadFunction, WAUrlInfo } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: HeadersInit;
+    };
+    uploadImage?: WAMediaUploadFunction;
+    logger?: ILogger;
+};
+/**
+ * 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>;
+//# sourceMappingURL=link-preview.d.ts.map

package/lib/Utils/logger.d.ts

@@ -0,0 +1,12 @@
+export interface ILogger {
+    level: string;
+    child(obj: Record<string, unknown>): ILogger;
+    trace(obj: unknown, msg?: string): void;
+    debug(obj: unknown, msg?: string): void;
+    info(obj: unknown, msg?: string): void;
+    warn(obj: unknown, msg?: string): void;
+    error(obj: unknown, msg?: string): void;
+}
+declare const _default: import("pino").Logger<never, boolean>;
+export default _default;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1,13 @@
+declare class LTHash {
+    salt: string;
+    constructor(e: string);
+    add(e: ArrayBuffer, t: ArrayBuffer[]): Promise<ArrayBuffer>;
+    subtract(e: ArrayBuffer, t: ArrayBuffer[]): Promise<ArrayBuffer>;
+    subtractThenAdd(e: ArrayBuffer, addList: ArrayBuffer[], subtractList: ArrayBuffer[]): Promise<ArrayBuffer>;
+    private _addSingle;
+    private _subtractSingle;
+    private performPointwiseWithOverflow;
+}
+export declare const LT_HASH_ANTI_TAMPERING: LTHash;
+export {};
+//# sourceMappingURL=lt-hash.d.ts.map

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

@@ -0,0 +1,8 @@
+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>;
+};
+//# sourceMappingURL=make-mutex.d.ts.map

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,82 @@
+import type { proto } from '../../WAProto/index.js';
+import type { ILogger } from './logger.js';
+export interface RecentMessageKey {
+    to: string;
+    id: string;
+}
+export interface RecentMessage {
+    message: proto.IMessage;
+    timestamp: number;
+}
+export interface SessionRecreateHistory {
+    [jid: string]: number;
+}
+export interface RetryCounter {
+    [messageId: string]: number;
+}
+export type PendingPhoneRequest = Record<string, ReturnType<typeof setTimeout>>;
+export interface RetryStatistics {
+    totalRetries: number;
+    successfulRetries: number;
+    failedRetries: number;
+    mediaRetries: number;
+    sessionRecreations: number;
+    phoneRequests: number;
+}
+export declare class MessageRetryManager {
+    private logger;
+    private recentMessagesMap;
+    private messageKeyIndex;
+    private sessionRecreateHistory;
+    private retryCounters;
+    private pendingPhoneRequests;
+    private readonly maxMsgRetryCount;
+    private statistics;
+    constructor(logger: ILogger, maxMsgRetryCount: number);
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: string, id: string, message: proto.IMessage): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: string, id: string): RecentMessage | undefined;
+    /**
+     * Check if a session should be recreated based on retry count and history
+     */
+    shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: string): number;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: string): number;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: string): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: string): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: string): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: string): void;
+    private keyToString;
+    private removeRecentMessage;
+}
+//# sourceMappingURL=message-retry-manager.d.ts.map

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

@@ -0,0 +1,114 @@
+import { Boom } from '@hapi/boom';
+import { Readable, Transform } from 'stream';
+import { URL } from 'url';
+import { proto } from '../../WAProto/index.js';
+import { type MediaType } from '../Defaults/index.js';
+import type { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent, WAMessageKey } from '../Types/index.js';
+import { type BinaryNode } from '../WABinary/index.js';
+import type { ILogger } from './logger.js';
+export declare const hkdfInfoKey: (type: MediaType) => string;
+export declare const getRawMediaUploadData: (media: WAMediaUpload, mediaType: MediaType, logger?: ILogger) => Promise<{
+    filePath: string;
+    fileSha256: Buffer<ArrayBufferLike>;
+    fileLength: number;
+}>;
+/** 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 const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+    buffer: any;
+    original: {
+        width: any;
+        height: any;
+    };
+}>;
+export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload, dimensions?: {
+    width: number;
+    height: number;
+}) => 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?: RequestInit & {
+    maxContentLength?: number;
+}) => 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?: RequestInit & {
+    isStream?: true;
+}) => Promise<Readable>;
+type EncryptedStreamOptions = {
+    saveOriginalFileIfRequired?: boolean;
+    logger?: ILogger;
+    opts?: RequestInit;
+};
+export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: Buffer<ArrayBufferLike>;
+    originalFilePath: string | undefined;
+    encFilePath: string;
+    mac: Buffer<ArrayBuffer>;
+    fileEncSha256: Buffer<ArrayBufferLike>;
+    fileSha256: Buffer<ArrayBufferLike>;
+    fileLength: number;
+}>;
+export type MediaDownloadOptions = {
+    startByte?: number;
+    endByte?: number;
+    options?: RequestInit;
+};
+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: WAMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => Promise<BinaryNode>;
+export declare const decodeMediaRetryNode: (node: BinaryNode) => {
+    key: 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) => 200 | 412 | 404 | 418;
+export {};
+//# sourceMappingURL=messages-media.d.ts.map

package/lib/Utils/messages-media.js

@@ -168,6 +168,7 @@ export const generateProfilePicture = async (mediaUpload) => {
         img: await img,
     }
 }
+
 /** gets the SHA256 of the given media message */
 export const mediaMessageSHA256B64 = (message) => {
     const media = Object.values(message)[0];
@@ -195,41 +196,55 @@ export async function getAudioDuration(buffer) {
  */
 export async function getAudioWaveform(buffer, logger) {
     try {
-        // @ts-ignore
-        const { default: decoder } = await import('audio-decode');
+        const { PassThrough } = require('stream');
+        const ff = require('fluent-ffmpeg');
+        
         let audioData;
         if (Buffer.isBuffer(buffer)) {
             audioData = buffer;
-        }
-        else if (typeof buffer === 'string') {
-            const rStream = createReadStream(buffer);
+        } else if (typeof buffer === 'string') {
+            const rStream = require('fs').createReadStream(buffer);
             audioData = await toBuffer(rStream);
-        }
-        else {
+        } else {
             audioData = await toBuffer(buffer);
         }
-        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 blockSize = Math.floor(rawData.length / samples); // the number of samples in each subdivision
-        const filteredData = [];
-        for (let i = 0; i < samples; i++) {
-            const blockStart = blockSize * i; // the location of the first sample in the block
-            let sum = 0;
-            for (let j = 0; j < blockSize; j++) {
-                sum = sum + Math.abs(rawData[blockStart + j]); // find the sum of all the samples in the block
-            }
-            filteredData.push(sum / blockSize); // divide the sum by the block size to get the average
-        }
-        // This guarantees that the largest data point will be set to 1, and the rest of the data will scale proportionally.
-        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)));
-        return waveform;
-    }
-    catch (e) {
-        logger?.debug('Failed to generate waveform: ' + e);
+
+        return await new Promise((resolve, reject) => {
+            const inputStream = new PassThrough();
+            inputStream.end(audioData);
+            const chunks = [];
+            const bars = 64;
+            
+            ff(inputStream)
+                .audioChannels(1)
+                .audioFrequency(16000)
+                .format('s16le')
+                .on('error', reject)
+                .on('end', () => {
+                    const rawData = Buffer.concat(chunks);
+                    const samples = rawData.length / 2;
+                    const amplitudes = [];
+                    
+                    for (let i = 0; i < samples; i++) {
+                        amplitudes.push(Math.abs(rawData.readInt16LE(i * 2)) / 32768);
+                    }
+                    
+                    const blockSize = Math.floor(amplitudes.length / bars);
+                    const avg = [];
+                    for (let i = 0; i < bars; i++) {
+                        const block = amplitudes.slice(i * blockSize, (i + 1) * blockSize);
+                        avg.push(block.reduce((a, b) => a + b, 0) / block.length);
+                    }
+                    
+                    const max = Math.max(...avg);
+                    const normalized = avg.map(v => Math.floor((v / max) * 100));
+                    resolve(new Uint8Array(normalized));
+                })
+                .pipe()
+                .on('data', chunk => chunks.push(chunk));
+        });
+    } catch (e) {
+        logger?.debug(e);
     }
 }
 export const toReadable = (buffer) => {
@@ -294,17 +309,38 @@ export async function generateThumbnail(file, mediaType, options) {
         originalImageDimensions
     };
 }
+/**
+ * Mengambil stream dari URL, mendukung Web ReadableStream dan Node.js Stream
+ */
 export const getHttpStream = async (url, options = {}) => {
     const response = await fetch(url.toString(), {
         dispatcher: options.dispatcher,
         method: 'GET',
         headers: options.headers
     });
+
     if (!response.ok) {
-        throw new Boom(`Failed to fetch stream from ${url}`, { statusCode: response.status, data: { url } });
+        throw new Boom(`Failed to fetch stream from ${url}`, {
+            statusCode: response.status,
+            data: { url }
+        });
     }
-    // @ts-ignore Node18+ Readable.fromWeb exists
-    return response.body instanceof Readable ? response.body : Readable.fromWeb(response.body);
+
+    const body = response.body;
+
+    // Jika body adalah Web ReadableStream (Node.js 18+), konversi
+    if (body && typeof body === 'object' && 'pipeTo' in body && typeof body.pipeTo === 'function') {
+        // @ts-ignore - Readable.fromWeb exists in Node.js 18+
+        return Readable.fromWeb(body);
+    }
+
+    // Jika body sudah Node.js Readable (misal: PassThrough dari node-fetch)
+    if (body && typeof body.pipe === 'function' && typeof body.read === 'function') {
+        return body;
+    }
+
+    // Fallback: buat stream kosong atau error
+    throw new Error('Response body is not a readable stream');
 };
 export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
     const { stream, type } = await getStream(media, opts);
@@ -660,4 +696,4 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
 };
-//# sourceMappingURL=messages-media.js.map
+//# sourceMappingURL=messages-media.js.map

package/lib/Utils/messages.d.ts

@@ -0,0 +1,89 @@
+import { type Transform } from 'stream';
+import { proto } from '../../WAProto/index.js';
+import type { AnyMediaMessageContent, AnyMessageContent, MessageContentGenerationOptions, MessageGenerationOptions, MessageGenerationOptionsFromContent, MessageUserReceipt, WAMessage, WAMessageContent, WAMessageKey } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+import { type MediaDownloadOptions } from './messages-media.js';
+/**
+ * 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/index.js").WAUrlInfo | undefined>;
+export declare const prepareWAMessageMedia: (message: AnyMediaMessageContent, options: MessageContentGenerationOptions) => 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) => WAMessage;
+export declare const generateWAMessage: (jid: string, content: AnyMessageContent, options: MessageGenerationOptions) => Promise<WAMessage>;
+/** Get the key to access the true type of content */
+export declare const getContentType: (content: proto.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;
+/** Update the message with a new event response */
+export declare const updateMessageWithEventResponse: (msg: Pick<WAMessage, "eventResponses">, update: proto.IEventResponse) => 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[];
+type ResponseAggregation = {
+    response: string;
+    responders: string[];
+};
+/**
+ * Aggregates all event responses in an event message.
+ * @param msg the event creation message
+ * @param meId your jid
+ * @returns A list of response types & their responders
+ */
+export declare function getAggregateResponsesInEventMessage({ eventResponses }: Pick<WAMessage, 'eventResponses'>, meId?: string): ResponseAggregation[];
+/** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
+export declare const aggregateMessageKeysNotFromMe: (keys: WAMessageKey[]) => {
+    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 {};
+//# sourceMappingURL=messages.d.ts.map

package/lib/Utils/messages.js

@@ -86,10 +86,10 @@ export const prepareWAMessageMedia = async (message, options) => {
         uploadData.mimetype = MIMETYPE_MAP[mediaType];
     }
     if (cacheableKey) {
-        const mediaBuff = await options.mediaCache.get(cacheableKey);
+        const mediaBuff = options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
             logger?.debug({ cacheableKey }, 'got media cache hit');
-            const obj = proto.Message.decode(mediaBuff);
+            const obj = WAProto.Message.decode(mediaBuff);
             const key = `${mediaType}Message`;
             Object.assign(obj[key], { ...uploadData, media: undefined });
             return obj;
@@ -121,12 +121,9 @@ export const prepareWAMessageMedia = async (message, options) => {
             obj.ptvMessage = obj.videoMessage;
             delete obj.videoMessage;
         }
-        if (obj.stickerMessage) {
-            obj.stickerMessage.stickerSentTs = Date.now();
-        }
         if (cacheableKey) {
             logger?.debug({ cacheableKey }, 'set cache');
-            await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
+            options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
         }
         return obj;
     }
@@ -211,7 +208,7 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
     if (cacheableKey) {
         logger?.debug({ cacheableKey }, 'set cache');
-        await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
+        options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
     }
     return obj;
 };
@@ -493,6 +490,39 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    else if ('payment' in message) {
+        const requestPaymentMessage = {
+            amount: {
+                currencyCode: message.payment?.currency || 'IDR',
+                offset: message.payment?.offset || 0,
+                value: message.payment?.amount || 999999999
+            },
+            expiryTimestamp: message.payment?.expiry || 0,
+            amount1000: message.payment?.amount || 999999999 * 1000,
+            currencyCodeIso4217: message.payment?.currency || 'IDR',
+            requestFrom: message.payment?.from || '0@s.whatsapp.net',
+            noteMessage: {
+                extendedTextMessage: {
+                    text: message.payment?.note || 'Notes'
+                }
+            },
+            background: {
+                placeholderArgb: message.payment?.image?.placeholderArgb || 4278190080,
+                textArgb: message.payment?.image?.textArgb || 4294967295,
+                subtextArgb: message.payment?.image?.subtextArgb || 4294967295,
+                type: 1
+            }
+        }
+
+        requestPaymentMessage.noteMessage.extendedTextMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? {
+                mentionedJid: message.mentions
+            } : {})
+        }
+
+        m.requestPaymentMessage = requestPaymentMessage
+    }
     else if ('sharePhoneNumber' in message) {
         m.protocolMessage = {
             type: proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
@@ -748,12 +778,12 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     const { quoted, userJid } = options;
     if (quoted && !isJidNewsletter(jid)) {
         const participant = quoted.key.fromMe
-            ? userJid // TODO: Add support for LIDs
+            ? userJid
             : quoted.participant || quoted.key.participant || quoted.key.remoteJid;
         let quotedMsg = normalizeMessageContent(quoted.message);
         const msgType = getContentType(quotedMsg);
         // strip any redundant properties
-        quotedMsg = proto.Message.create({ [msgType]: quotedMsg[msgType] });
+        quotedMsg = proto.Message.fromObject({ [msgType]: quotedMsg[msgType] });
         const quotedContent = quotedMsg[msgType];
         if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) {
             delete quotedContent.contextInfo;
@@ -788,7 +818,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
             //ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
         };
     }
-    message = WAProto.Message.create(message);
+    message = WAProto.Message.fromObject(message);
     const messageJSON = {
         key: {
             remoteJid: jid,
@@ -798,7 +828,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         message: message,
         messageTimestamp: timestamp,
         messageStubParameters: [],
-        participant: isJidGroup(jid) || isJidStatusBroadcast(jid) ? userJid : undefined, // TODO: Add support for LIDs
+        participant: isJidGroup(jid) || isJidStatusBroadcast(jid) ? userJid : undefined,
         status: WAMessageStatus.PENDING
     };
     return WAProto.WebMessageInfo.fromObject(messageJSON);
@@ -1109,4 +1139,4 @@ export const patchMessageForMdIfRequired = (message) => {
         }
     }
     return message
-}
+}

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

@@ -0,0 +1,20 @@
+import { proto } from '../../WAProto/index.js';
+import type { KeyPair } from '../Types/index.js';
+import type { BinaryNode } from '../WABinary/index.js';
+import type { ILogger } from './logger.js';
+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>;
+};
+//# sourceMappingURL=noise-handler.d.ts.map