@neelegirl/baileys 1.5.6 → 1.5.8

package/lib/Utils/lt-hash.js

@@ -1,48 +1,58 @@
-import { hkdf } from './crypto.js';
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("./crypto")
+
 /**
  * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
  * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
  * if the same series of mutations was made sequentially.
  */
-const o = 128;
-class LTHash {
+const o = 128
+class d {
     constructor(e) {
-        this.salt = e;
+        this.salt = e
     }
-    async add(e, t) {
+    add(e, t) {
+        var r = this
         for (const item of t) {
-            e = await this._addSingle(e, item);
+            e = r._addSingle(e, item)
         }
-        return e;
+        return e
     }
-    async subtract(e, t) {
+    subtract(e, t) {
+        var r = this
         for (const item of t) {
-            e = await this._subtractSingle(e, item);
+            e = r._subtractSingle(e, item)
         }
-        return e;
+        return e
     }
-    async subtractThenAdd(e, addList, subtractList) {
-        const subtracted = await this.subtract(e, subtractList);
-        return this.add(subtracted, addList);
+    subtractThenAdd(e, t, r) {
+        var n = this
+        return n.add(n.subtract(e, r), t)
     }
     async _addSingle(e, t) {
-        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
+        var r = this
+        const n = new Uint8Array(await crypto_1.hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e + t))
     }
     async _subtractSingle(e, t) {
-        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
+        var r = this
+        const n = new Uint8Array(await crypto_1.hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e - t))
     }
-    performPointwiseWithOverflow(e, t, op) {
-        const n = new DataView(e);
-        const i = new DataView(t);
-        const out = new ArrayBuffer(n.byteLength);
-        const s = new DataView(out);
-        for (let offset = 0; offset < n.byteLength; offset += 2) {
-            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
+    performPointwiseWithOverflow(e, t, r) {
+        const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a)
+        for (let e = 0; e < n.byteLength; e += 2) {
+            s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0)
         }
-        return out;
+        return a
     }
 }
-export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');
-//# sourceMappingURL=lt-hash.js.map
+
+const LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')
+
+module.exports = {
+  LT_HASH_ANTI_TAMPERING
+}

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

@@ -1,8 +1,9 @@
 export declare const makeMutex: () => {
-    mutex<T>(code: () => Promise<T> | T): Promise<T>;
-};
-export type Mutex = ReturnType<typeof makeMutex>;
+    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>;
-};
-//# sourceMappingURL=make-mutex.d.ts.map
+    mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>
+}

package/lib/Utils/make-mutex.js

@@ -1,40 +1,49 @@
-export const makeMutex = () => {
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const makeMutex = () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let task = Promise.resolve();
-    let taskTimeout;
+    let task = Promise.resolve()
+    let taskTimeout
     return {
         mutex(code) {
             task = (async () => {
                 // wait for the previous task to complete
                 // if there is an error, we swallow so as to not block the queue
                 try {
-                    await task;
+                    await task
                 }
-                catch { }
+                catch (_a) { }
                 try {
                     // execute the current task
-                    const result = await code();
-                    return result;
+                    const result = await code()
+                    return result
                 }
                 finally {
-                    clearTimeout(taskTimeout);
+                    clearTimeout(taskTimeout)
                 }
-            })();
+            })()
             // we replace the existing task, appending the new piece of execution to it
             // so the next task will have to wait for this one to finish
-            return task;
-        }
-    };
-};
-export const makeKeyedMutex = () => {
-    const map = {};
+            return task
+        },
+    }
+}
+
+const makeKeyedMutex = () => {
+    const map = {}
     return {
         mutex(key, task) {
             if (!map[key]) {
-                map[key] = makeMutex();
+                map[key] = makeMutex()
             }
-            return map[key].mutex(task);
+            return map[key].mutex(task)
         }
-    };
-};
-//# sourceMappingURL=make-mutex.js.map
+    }
+}
+
+module.exports = {
+  makeMutex, 
+  makeKeyedMutex
+}

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

@@ -1,5 +1,5 @@
-import type { proto } from '../../WAProto/index.js';
-import type { ILogger } from './logger.js';
+import type { proto } from '../../WAProto';
+import type { ILogger } from './logger';
 export interface RecentMessageKey {
     to: string;
     id: string;
@@ -14,9 +14,7 @@ export interface SessionRecreateHistory {
 export interface RetryCounter {
     [messageId: string]: number;
 }
-export interface PendingPhoneRequest {
-    [messageId: string]: NodeJS.Timeout;
-}
+export type PendingPhoneRequest = Record<string, ReturnType<typeof setTimeout>>;
 export interface RetryStatistics {
     totalRetries: number;
     successfulRetries: number;
@@ -28,6 +26,7 @@ export interface RetryStatistics {
 export declare class MessageRetryManager {
     private logger;
     private recentMessagesMap;
+    private messageKeyIndex;
     private sessionRecreateHistory;
     private retryCounters;
     private pendingPhoneRequests;
@@ -78,5 +77,6 @@ export declare class MessageRetryManager {
      */
     cancelPendingPhoneRequest(messageId: string): void;
     private keyToString;
+    private removeRecentMessage;
 }
-//# sourceMappingURL=message-retry-manager.d.ts.map
+

package/lib/Utils/message-retry-manager.js

@@ -1,20 +1,34 @@
-import { LRUCache } from 'lru-cache';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRetryManager = void 0;
+const lru_cache_1 = require("lru-cache");
 /** Number of sent messages to cache in memory for handling retry receipts */
 const RECENT_MESSAGES_SIZE = 512;
+const MESSAGE_KEY_SEPARATOR = '\u0000';
 /** Timeout for session recreation - 1 hour */
 const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
 const PHONE_REQUEST_DELAY = 3000;
-export class MessageRetryManager {
+class MessageRetryManager {
     constructor(logger, maxMsgRetryCount) {
         this.logger = logger;
-        this.recentMessagesMap = new LRUCache({
-            max: RECENT_MESSAGES_SIZE
+        this.recentMessagesMap = new lru_cache_1.LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            ttlAutopurge: true,
+            dispose: (_value, key) => {
+                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+                if (separatorIndex > -1) {
+                    const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length);
+                    this.messageKeyIndex.delete(messageId);
+                }
+            }
         });
-        this.sessionRecreateHistory = new LRUCache({
+        this.messageKeyIndex = new Map();
+        this.sessionRecreateHistory = new lru_cache_1.LRUCache({
             ttl: RECREATE_SESSION_TIMEOUT * 2,
             ttlAutopurge: true
         });
-        this.retryCounters = new LRUCache({
+        this.retryCounters = new lru_cache_1.LRUCache({
             ttl: 15 * 60 * 1000,
             ttlAutopurge: true,
             updateAgeOnGet: true
@@ -42,6 +56,7 @@ export class MessageRetryManager {
             message,
             timestamp: Date.now()
         });
+        this.messageKeyIndex.set(id, keyStr);
         this.logger.debug(`Added message to retry cache: ${to}/${id}`);
     }
     /**
@@ -110,6 +125,7 @@ export class MessageRetryManager {
         // Clean up retry counter for successful message
         this.retryCounters.delete(messageId);
         this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
     }
     /**
      * Mark retry as failed
@@ -117,6 +133,8 @@ export class MessageRetryManager {
     markRetryFailed(messageId) {
         this.statistics.failedRetries++;
         this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
     }
     /**
      * Schedule a phone request with delay
@@ -143,7 +161,17 @@ export class MessageRetryManager {
         }
     }
     keyToString(key) {
-        return `${key.to}:${key.id}`;
+        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+    }
+    removeRecentMessage(messageId) {
+        const keyStr = this.messageKeyIndex.get(messageId);
+        if (!keyStr) {
+            return;
+        }
+        this.recentMessagesMap.delete(keyStr);
+        this.messageKeyIndex.delete(messageId);
     }
 }
-//# sourceMappingURL=message-retry-manager.js.map
+exports.MessageRetryManager = MessageRetryManager;
+//# sourceMappingURL=message-retry-manager.js.map
+

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

@@ -1,114 +1,129 @@
-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;
-}>;
+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 getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo
+
 export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: any;
+    buffer: Buffer
     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>;
-}>;
+        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>;
+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";
+export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): 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: "readable"
 } | {
-    readonly stream: Readable;
-    readonly type: "remote";
+    readonly stream: Readable
+    readonly type: "remote"
 } | {
-    readonly stream: import("fs").ReadStream;
-    readonly type: "file";
-}>;
+    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;
+    logger?: Logger
 }): Promise<{
-    thumbnail: string | undefined;
+    thumbnail: string | undefined
     originalImageDimensions: {
-        width: number;
-        height: number;
-    } | undefined;
-}>;
-export declare const getHttpStream: (url: string | URL, options?: RequestInit & {
-    isStream?: true;
-}) => Promise<Readable>;
+        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?: RequestInit;
-};
+    saveOriginalFileIfRequired?: boolean
+    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>;
-    fileLength: number;
-}>;
+    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?: RequestInit;
-};
-export declare const getUrlFromDirectPath: (directPath: string) => string;
-export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>;
+    startByte?: number
+    endByte?: number
+    options?: AxiosRequestConfig<{}>
+}
+
+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;
+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 encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode
+
 export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: WAMessageKey;
+    key: proto.IMessageKey
     media?: {
-        ciphertext: Uint8Array;
-        iv: Uint8Array;
-    };
-    error?: Boom;
-};
+        ciphertext: Uint8Array
+        iv: Uint8Array
+    } | undefined
+    error?: Boom<any> | undefined
+}
+
 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
+    ciphertext: Uint8Array
+    iv: Uint8Array
+}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>
+
+export declare const getStatusCodeForMediaRetry: (code: number) => any
+
+export {}