lordceaser-baileys 1.0.19 → 1.0.21

package/lib/Utils/lt-hash.js

@@ -30,15 +30,15 @@ class d {
         var n = this;
         return n.add(n.subtract(e, r), t);
     }
-    async _addSingle(e, t) {
+    _addSingle(e, t) {
         var r = this;
-        const n = new Uint8Array(await (0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
-        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e + t));
+        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
+        return r.performPointwiseWithOverflow(e, n, ((e, t) => e + t));
     }
-    async _subtractSingle(e, t) {
+    _subtractSingle(e, t) {
         var r = this;
-        const n = new Uint8Array(await (0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
-        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e - t));
+        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
+        return r.performPointwiseWithOverflow(e, n, ((e, t) => e - t));
     }
     performPointwiseWithOverflow(e, t, r) {
         const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a);

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

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

package/lib/Utils/make-mutex.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeKeyedMutex = exports.makeMutex = void 0;
 const makeMutex = () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let task = Promise.resolve();
     let taskTimeout;
     return {

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

@@ -1,16 +1,19 @@
+/// <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';
-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 getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo;
 export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: Buffer<ArrayBufferLike>;
+    buffer: Buffer;
     original: {
         width: number | undefined;
         height: number | undefined;
@@ -18,7 +21,7 @@ export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | s
 }>;
 export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
 export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
-    img: Buffer<ArrayBufferLike>;
+    img: Buffer;
 }>;
 /** gets the SHA256 of the given media message */
 export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined;
@@ -26,9 +29,9 @@ export declare function getAudioDuration(buffer: Buffer | string | Readable): Pr
 /**
   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 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<ArrayBuffer>>;
+export declare const toBuffer: (stream: Readable) => Promise<Buffer>;
 export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
     readonly stream: Readable;
     readonly type: "buffer";
@@ -44,7 +47,7 @@ export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig)
 }>;
 /** generates a thumbnail for a given media, if required */
 export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
-    logger?: ILogger;
+    logger?: Logger;
 }): Promise<{
     thumbnail: string | undefined;
     originalImageDimensions: {
@@ -57,22 +60,23 @@ export declare const getHttpStream: (url: string | URL, options?: AxiosRequestCo
 }) => Promise<Readable>;
 type EncryptedStreamOptions = {
     saveOriginalFileIfRequired?: boolean;
-    logger?: ILogger;
+    logger?: Logger;
     opts?: AxiosRequestConfig;
 };
 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>;
+    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<{}>;
+    options?: AxiosRequestConfig<any>;
 };
 export declare const getUrlFromDirectPath: (directPath: string) => string;
 export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>;
@@ -86,18 +90,18 @@ export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logg
 /**
  * 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 encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode;
 export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: import("../Types").WAMessageKey;
+    key: proto.IMessageKey;
     media?: {
         ciphertext: Uint8Array;
         iv: Uint8Array;
-    };
-    error?: Boom;
+    } | undefined;
+    error?: Boom<any> | undefined;
 };
 export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
     ciphertext: Uint8Array;
     iv: Uint8Array;
-}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>;
+}, mediaKey: Uint8Array, msgId: string) => proto.MediaRetryNotification;
 export declare const getStatusCodeForMediaRetry: (code: number) => any;
 export {};

package/lib/Utils/messages-media.js

@@ -15,33 +15,18 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStatusCodeForMediaRetry = exports.decryptMediaRetryData = exports.decodeMediaRetryNode = exports.encryptMediaRetryRequest = exports.getWAUploadToServer = exports.downloadEncryptedContent = exports.downloadContentFromMessage = exports.getUrlFromDirectPath = exports.encryptedStream = exports.getHttpStream = exports.getStream = exports.toBuffer = exports.toReadable = exports.mediaMessageSHA256B64 = exports.generateProfilePicture = exports.encodeBase64EncodedStringForUpload = exports.extractImageThumb = exports.hkdfInfoKey = void 0;
-exports.getMediaKeys = getMediaKeys;
-exports.getAudioDuration = getAudioDuration;
-exports.getAudioWaveform = getAudioWaveform;
-exports.generateThumbnail = generateThumbnail;
-exports.extensionForMediaMessage = extensionForMediaMessage;
+exports.getStatusCodeForMediaRetry = exports.decryptMediaRetryData = exports.decodeMediaRetryNode = exports.encryptMediaRetryRequest = exports.getWAUploadToServer = exports.extensionForMediaMessage = exports.downloadEncryptedContent = exports.downloadContentFromMessage = exports.getUrlFromDirectPath = exports.encryptedStream = exports.getHttpStream = exports.generateThumbnail = exports.getStream = exports.toBuffer = exports.toReadable = exports.getAudioWaveform = exports.getAudioDuration = exports.mediaMessageSHA256B64 = exports.generateProfilePicture = exports.encodeBase64EncodedStringForUpload = exports.extractImageThumb = exports.getMediaKeys = exports.hkdfInfoKey = void 0;
 const boom_1 = require("@hapi/boom");
 const axios_1 = __importDefault(require("axios"));
 const child_process_1 = require("child_process");
@@ -60,11 +45,13 @@ const getTmpFilesDirectory = () => (0, os_1.tmpdir)();
 const getImageProcessingLibrary = async () => {
     const [_jimp, sharp] = await Promise.all([
         (async () => {
-            const jimp = await (Promise.resolve().then(() => __importStar(require('jimp'))).catch(() => { }));
+            const jimp = await (import('jimp')
+                .catch(() => { }));
             return jimp;
         })(),
         (async () => {
-            const sharp = await (Promise.resolve().then(() => __importStar(require('sharp'))).catch(() => { }));
+            const sharp = await (import('sharp')
+                .catch(() => { }));
             return sharp;
         })()
     ]);
@@ -83,7 +70,7 @@ const hkdfInfoKey = (type) => {
 };
 exports.hkdfInfoKey = hkdfInfoKey;
 /** generates all the keys required to encrypt/decrypt & sign a media message */
-async function getMediaKeys(buffer, mediaType) {
+function getMediaKeys(buffer, mediaType) {
     if (!buffer) {
         throw new boom_1.Boom('Cannot derive from empty media key');
     }
@@ -91,13 +78,14 @@ async function getMediaKeys(buffer, mediaType) {
         buffer = Buffer.from(buffer.replace('data:;base64,', ''), 'base64');
     }
     // expand using HKDF to 112 bytes, also pass in the relevant app info
-    const expandedMediaKey = await (0, crypto_1.hkdf)(buffer, 112, { info: (0, exports.hkdfInfoKey)(mediaType) });
+    const expandedMediaKey = (0, crypto_1.hkdf)(buffer, 112, { info: (0, exports.hkdfInfoKey)(mediaType) });
     return {
         iv: expandedMediaKey.slice(0, 16),
         cipherKey: expandedMediaKey.slice(16, 48),
         macKey: expandedMediaKey.slice(48, 80),
     };
 }
+exports.getMediaKeys = getMediaKeys;
 /** Extracts video thumb using FFMPEG */
 const extractVideoThumb = async (path, destPath, time, size) => new Promise((resolve, reject) => {
     const cmd = `ffmpeg -ss ${time} -i ${path} -y -vf scale=${size.width}:-1 -vframes 1 -f image2 ${destPath}`;
@@ -204,7 +192,7 @@ const mediaMessageSHA256B64 = (message) => {
 };
 exports.mediaMessageSHA256B64 = mediaMessageSHA256B64;
 async function getAudioDuration(buffer) {
-    const musicMetadata = await Promise.resolve().then(() => __importStar(require('music-metadata')));
+    const musicMetadata = await import('music-metadata');
     let metadata;
     if (Buffer.isBuffer(buffer)) {
         metadata = await musicMetadata.parseBuffer(buffer, undefined, { duration: true });
@@ -223,12 +211,13 @@ async function getAudioDuration(buffer) {
     }
     return metadata.format.duration;
 }
+exports.getAudioDuration = getAudioDuration;
 /**
   referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
  */
 async function getAudioWaveform(buffer, logger) {
     try {
-        const { default: decoder } = await eval('import(\'audio-decode\')');
+        const audioDecode = (buffer) => import('audio-decode').then(({ default: audioDecode }) => audioDecode(buffer));
         let audioData;
         if (Buffer.isBuffer(buffer)) {
             audioData = buffer;
@@ -240,7 +229,7 @@ async function getAudioWaveform(buffer, logger) {
         else {
             audioData = await (0, exports.toBuffer)(buffer);
         }
-        const audioBuffer = await decoder(audioData);
+        const audioBuffer = await audioDecode(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
@@ -264,6 +253,7 @@ async function getAudioWaveform(buffer, logger) {
         logger === null || logger === void 0 ? void 0 : logger.debug('Failed to generate waveform: ' + e);
     }
 }
+exports.getAudioWaveform = getAudioWaveform;
 const toReadable = (buffer) => {
     const readable = new stream_1.Readable({ read: () => { } });
     readable.push(buffer);
@@ -309,7 +299,7 @@ async function generateThumbnail(file, mediaType, options) {
         }
     }
     else if (mediaType === 'video') {
-        const imgFilename = (0, path_1.join)(getTmpFilesDirectory(), (0, generics_1.generateMessageIDV2)() + '.jpg');
+        const imgFilename = (0, path_1.join)(getTmpFilesDirectory(), (0, generics_1.generateMessageID)() + '.jpg');
         try {
             await extractVideoThumb(file, imgFilename, '00:00:00', { width: 32, height: 32 });
             const buff = await fs_1.promises.readFile(imgFilename);
@@ -325,35 +315,34 @@ async function generateThumbnail(file, mediaType, options) {
         originalImageDimensions
     };
 }
+exports.generateThumbnail = generateThumbnail;
 const getHttpStream = async (url, options = {}) => {
     const fetched = await axios_1.default.get(url.toString(), { ...options, responseType: 'stream' });
     return fetched.data;
 };
 exports.getHttpStream = getHttpStream;
 const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
-    var _a, _b;
     const { stream, type } = await (0, exports.getStream)(media, opts);
     logger === null || logger === void 0 ? void 0 : logger.debug('fetched media stream');
     const mediaKey = Crypto.randomBytes(32);
-    const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
-    const encFilePath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageIDV2)() + '-enc');
-    const encFileWriteStream = (0, fs_1.createWriteStream)(encFilePath);
-    let originalFileStream;
-    let originalFilePath;
-    if (saveOriginalFileIfRequired) {
-        originalFilePath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageIDV2)() + '-original');
-        originalFileStream = (0, fs_1.createWriteStream)(originalFilePath);
+    const { cipherKey, iv, macKey } = getMediaKeys(mediaKey, mediaType);
+    const encWriteStream = new stream_1.Readable({ read: () => { } });
+    let bodyPath;
+    let writeStream;
+    let didSaveToTmpPath = false;
+    if (type === 'file') {
+        bodyPath = media.url;
+    }
+    else if (saveOriginalFileIfRequired) {
+        bodyPath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageID)());
+        writeStream = (0, fs_1.createWriteStream)(bodyPath);
+        didSaveToTmpPath = true;
     }
     let fileLength = 0;
     const aes = Crypto.createCipheriv('aes-256-cbc', cipherKey, iv);
-    const hmac = Crypto.createHmac('sha256', macKey).update(iv);
-    const sha256Plain = Crypto.createHash('sha256');
-    const sha256Enc = Crypto.createHash('sha256');
-    const onChunk = (buff) => {
-        sha256Enc.update(buff);
-        hmac.update(buff);
-        encFileWriteStream.write(buff);
-    };
+    let hmac = Crypto.createHmac('sha256', macKey).update(iv);
+    let sha256Plain = Crypto.createHash('sha256');
+    let sha256Enc = Crypto.createHash('sha256');
     try {
         for await (const data of stream) {
             fileLength += data.length;
@@ -364,54 +353,59 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
                     data: { media, type }
                 });
             }
-            if (originalFileStream) {
-                if (!originalFileStream.write(data)) {
-                    await (0, events_1.once)(originalFileStream, 'drain');
+            sha256Plain = sha256Plain.update(data);
+            if (writeStream) {
+                if (!writeStream.write(data)) {
+                    await (0, events_1.once)(writeStream, 'drain');
                 }
             }
-            sha256Plain.update(data);
             onChunk(aes.update(data));
         }
         onChunk(aes.final());
         const mac = hmac.digest().slice(0, 10);
-        sha256Enc.update(mac);
+        sha256Enc = sha256Enc.update(mac);
         const fileSha256 = sha256Plain.digest();
         const fileEncSha256 = sha256Enc.digest();
-        encFileWriteStream.write(mac);
-        encFileWriteStream.end();
-        (_a = originalFileStream === null || originalFileStream === void 0 ? void 0 : originalFileStream.end) === null || _a === void 0 ? void 0 : _a.call(originalFileStream);
+        encWriteStream.push(mac);
+        encWriteStream.push(null);
+        writeStream === null || writeStream === void 0 ? void 0 : writeStream.end();
         stream.destroy();
         logger === null || logger === void 0 ? void 0 : logger.debug('encrypted data successfully');
         return {
             mediaKey,
-            originalFilePath,
-            encFilePath,
+            encWriteStream,
+            bodyPath,
             mac,
             fileEncSha256,
             fileSha256,
-            fileLength
+            fileLength,
+            didSaveToTmpPath
         };
     }
     catch (error) {
         // destroy all streams with error
-        encFileWriteStream.destroy();
-        (_b = originalFileStream === null || originalFileStream === void 0 ? void 0 : originalFileStream.destroy) === null || _b === void 0 ? void 0 : _b.call(originalFileStream);
+        encWriteStream.destroy();
+        writeStream === null || writeStream === void 0 ? void 0 : writeStream.destroy();
         aes.destroy();
         hmac.destroy();
         sha256Plain.destroy();
         sha256Enc.destroy();
         stream.destroy();
-        try {
-            await fs_1.promises.unlink(encFilePath);
-            if (originalFilePath) {
-                await fs_1.promises.unlink(originalFilePath);
+        if (didSaveToTmpPath) {
+            try {
+                await fs_1.promises.unlink(bodyPath);
+            }
+            catch (err) {
+                logger === null || logger === void 0 ? void 0 : logger.error({ err }, 'failed to save to tmp path');
             }
-        }
-        catch (err) {
-            logger === null || logger === void 0 ? void 0 : logger.error({ err }, 'failed deleting tmp files');
         }
         throw error;
     }
+    function onChunk(buff) {
+        sha256Enc = sha256Enc.update(buff);
+        hmac = hmac.update(buff);
+        encWriteStream.push(buff);
+    }
 };
 exports.encryptedStream = encryptedStream;
 const DEF_HOST = 'mmg.whatsapp.net';
@@ -421,9 +415,9 @@ const toSmallestChunkSize = (num) => {
 };
 const getUrlFromDirectPath = (directPath) => `https://${DEF_HOST}${directPath}`;
 exports.getUrlFromDirectPath = getUrlFromDirectPath;
-const downloadContentFromMessage = async ({ mediaKey, directPath, url }, type, opts = {}) => {
+const downloadContentFromMessage = ({ mediaKey, directPath, url }, type, opts = {}) => {
     const downloadUrl = url || (0, exports.getUrlFromDirectPath)(directPath);
-    const keys = await getMediaKeys(mediaKey, type);
+    const keys = getMediaKeys(mediaKey, type);
     return (0, exports.downloadEncryptedContent)(downloadUrl, keys, opts);
 };
 exports.downloadContentFromMessage = downloadContentFromMessage;
@@ -530,8 +524,9 @@ function extensionForMediaMessage(message) {
     }
     return extension;
 }
+exports.extensionForMediaMessage = extensionForMediaMessage;
 const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (filePath, { mediaType, fileEncSha256B64, timeoutMs }) => {
+    return async (stream, { mediaType, fileEncSha256B64, timeoutMs }) => {
         var _a, _b;
         // send a query JSON to obtain the url & auth token to upload our media
         let uploadInfo = await refreshMediaConn(false);
@@ -542,12 +537,10 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
             logger.debug(`uploading to "${hostname}"`);
             const auth = encodeURIComponent(uploadInfo.auth); // the auth token
             const url = `https://${hostname}${Defaults_1.MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             let result;
             try {
-                const body = await axios_1.default.post(url, (0, fs_1.createReadStream)(filePath), {
+                const body = await axios_1.default.post(url, stream, {
                     ...options,
-                    maxRedirects: 0,
                     headers: {
                         ...options.headers || {},
                         'Content-Type': 'application/octet-stream',
@@ -593,11 +586,11 @@ const getMediaRetryKey = (mediaKey) => {
 /**
  * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
  */
-const encryptMediaRetryRequest = async (key, mediaKey, meId) => {
+const encryptMediaRetryRequest = (key, mediaKey, meId) => {
     const recp = { stanzaId: key.id };
     const recpBuffer = WAProto_1.proto.ServerErrorReceipt.encode(recp).finish();
     const iv = Crypto.randomBytes(12);
-    const retryKey = await getMediaRetryKey(mediaKey);
+    const retryKey = getMediaRetryKey(mediaKey);
     const ciphertext = (0, crypto_1.aesEncryptGCM)(recpBuffer, retryKey, iv, Buffer.from(key.id));
     const req = {
         tag: 'receipt',
@@ -661,8 +654,8 @@ const decodeMediaRetryNode = (node) => {
     return event;
 };
 exports.decodeMediaRetryNode = decodeMediaRetryNode;
-const decryptMediaRetryData = async ({ ciphertext, iv }, mediaKey, msgId) => {
-    const retryKey = await getMediaRetryKey(mediaKey);
+const decryptMediaRetryData = ({ ciphertext, iv }, mediaKey, msgId) => {
+    const retryKey = getMediaRetryKey(mediaKey);
     const plaintext = (0, crypto_1.aesDecryptGCM)(ciphertext, retryKey, iv, Buffer.from(msgId));
     return WAProto_1.proto.MediaRetryNotification.decode(plaintext);
 };
@@ -675,3 +668,7 @@ const MEDIA_RETRY_STATUS_MAP = {
     [WAProto_1.proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [WAProto_1.proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418,
 };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function __importStar(arg0) {
+    throw new Error('Function not implemented.');
+}

package/lib/Utils/messages.d.ts

@@ -1,7 +1,9 @@
+/// <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 { ILogger } from './logger';
 import { MediaDownloadOptions } from './messages-media';
 /**
  * Uses a regex to test whether the string contains a URL, and returns the URL if it does.
@@ -9,7 +11,7 @@ import { MediaDownloadOptions } from './messages-media';
  * @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 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;
 /**
@@ -40,11 +42,11 @@ export declare const extractMessageContent: (content: WAMessageContent | undefin
  */
 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;
+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;
+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;
+export declare const updateMessageWithPollUpdate: (msg: Pick<WAMessage, 'pollUpdates'>, update: proto.IPollUpdate) => void;
 type VoteAggregation = {
     name: string;
     voters: string[];
@@ -64,12 +66,12 @@ export declare const aggregateMessageKeysNotFromMe: (keys: proto.IMessageKey[])
 }[];
 type DownloadMediaMessageContext = {
     reuploadRequest: (msg: WAMessage) => Promise<WAMessage>;
-    logger: ILogger;
+    logger: Logger;
 };
 /**
  * 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>;
+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 {};