gifted-baileys 1.5.0 → 1.5.5

package/{lib → src}/Utils/history.js

@@ -1,4 +1,20 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHistoryMsg = exports.downloadAndProcessHistorySyncNotification = exports.processHistoryMessage = exports.downloadHistory = void 0;
 const util_1 = require("util");
@@ -10,18 +26,31 @@ const generics_1 = require("./generics");
 const messages_1 = require("./messages");
 const messages_media_1 = require("./messages-media");
 const inflatePromise = (0, util_1.promisify)(zlib_1.inflate);
-const downloadHistory = async (msg, options) => {
-    const stream = await (0, messages_media_1.downloadContentFromMessage)(msg, 'md-msg-hist', { options });
+const downloadHistory = (msg, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_1, _b, _c;
+    const stream = yield (0, messages_media_1.downloadContentFromMessage)(msg, 'md-msg-hist', { options });
     const bufferArray = [];
-    for await (const chunk of stream) {
-        bufferArray.push(chunk);
+    try {
+        for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+            _c = stream_1_1.value;
+            _d = false;
+            const chunk = _c;
+            bufferArray.push(chunk);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     let buffer = Buffer.concat(bufferArray);
     // decompress buffer
-    buffer = await inflatePromise(buffer);
+    buffer = yield inflatePromise(buffer);
     const syncData = WAProto_1.proto.HistorySync.decode(buffer);
     return syncData;
-};
+});
 exports.downloadHistory = downloadHistory;
 const processHistoryMessage = (item) => {
     var _a, _b, _c;
@@ -61,7 +90,7 @@ const processHistoryMessage = (item) => {
                 if ((0, WABinary_1.isJidUser)(chat.id) && chat.readOnly && chat.archived) {
                     delete chat.readOnly;
                 }
-                chats.push({ ...chat });
+                chats.push(Object.assign({}, chat));
             }
             break;
         case WAProto_1.proto.HistorySync.HistorySyncType.PUSH_NAME:
@@ -77,10 +106,10 @@ const processHistoryMessage = (item) => {
     };
 };
 exports.processHistoryMessage = processHistoryMessage;
-const downloadAndProcessHistorySyncNotification = async (msg, options) => {
-    const historyMsg = await (0, exports.downloadHistory)(msg, options);
+const downloadAndProcessHistorySyncNotification = (msg, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const historyMsg = yield (0, exports.downloadHistory)(msg, options);
     return (0, exports.processHistoryMessage)(historyMsg);
-};
+});
 exports.downloadAndProcessHistorySyncNotification = downloadAndProcessHistorySyncNotification;
 const getHistoryMsg = (message) => {
     var _a;

package/src/Utils/history.ts

@@ -0,0 +1,112 @@
+import { AxiosRequestConfig } from 'axios'
+import { promisify } from 'util'
+import { inflate } from 'zlib'
+import { proto } from '../../WAProto'
+import { Chat, Contact, WAMessageStubType } from '../Types'
+import { isJidUser } from '../WABinary'
+import { toNumber } from './generics'
+import { normalizeMessageContent } from './messages'
+import { downloadContentFromMessage } from './messages-media'
+
+const inflatePromise = promisify(inflate)
+
+export const downloadHistory = async(
+	msg: proto.Message.IHistorySyncNotification,
+	options: AxiosRequestConfig<any>
+) => {
+	const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options })
+	const bufferArray: Buffer[] = []
+	for await (const chunk of stream) {
+		bufferArray.push(chunk)
+	}
+
+	let buffer = Buffer.concat(bufferArray)
+
+	// decompress buffer
+	buffer = await inflatePromise(buffer)
+
+	const syncData = proto.HistorySync.decode(buffer)
+	return syncData
+}
+
+export const processHistoryMessage = (item: proto.IHistorySync) => {
+	const messages: proto.IWebMessageInfo[] = []
+	const contacts: Contact[] = []
+	const chats: Chat[] = []
+
+	switch (item.syncType) {
+	case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+	case proto.HistorySync.HistorySyncType.RECENT:
+	case proto.HistorySync.HistorySyncType.FULL:
+		for(const chat of item.conversations! as Chat[]) {
+			contacts.push({ id: chat.id, name: chat.name || undefined })
+
+			const msgs = chat.messages || []
+			delete chat.messages
+			delete chat.archived
+			delete chat.muteEndTime
+			delete chat.pinned
+
+			for(const item of msgs) {
+				const message = item.message!
+				messages.push(message)
+
+				if(!chat.messages?.length) {
+					// keep only the most recent message in the chat array
+					chat.messages = [{ message }]
+				}
+
+				if(!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+					chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp)
+				}
+
+				if(
+					(message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP
+					|| message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB
+					)
+					&& message.messageStubParameters?.[0]
+				) {
+					contacts.push({
+						id: message.key.participant || message.key.remoteJid!,
+						verifiedName: message.messageStubParameters?.[0],
+					})
+				}
+			}
+
+			if(isJidUser(chat.id) && chat.readOnly && chat.archived) {
+				delete chat.readOnly
+			}
+
+			chats.push({ ...chat })
+		}
+
+		break
+	case proto.HistorySync.HistorySyncType.PUSH_NAME:
+		for(const c of item.pushnames!) {
+			contacts.push({ id: c.id!, notify: c.pushname! })
+		}
+
+		break
+	}
+
+	return {
+		chats,
+		contacts,
+		messages,
+	}
+}
+
+export const downloadAndProcessHistorySyncNotification = async(
+	msg: proto.Message.IHistorySyncNotification,
+	options: AxiosRequestConfig<any>
+) => {
+	const historyMsg = await downloadHistory(msg, options)
+	return processHistoryMessage(historyMsg)
+}
+
+export const getHistoryMsg = (message: proto.IMessage) => {
+	const normalizedContent = !!message ? normalizeMessageContent(message) : undefined
+	const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification
+
+	return anyHistoryMsg
+}

package/src/Utils/index.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 → src}/Utils/link-preview.js

@@ -1,39 +1,78 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : 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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUrlInfo = void 0;
 const messages_1 = require("./messages");
 const messages_media_1 = require("./messages-media");
 const THUMBNAIL_WIDTH_PX = 192;
 /** Fetches an image and generates a thumbnail for it */
-const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
-    const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts);
-    const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth);
+const getCompressedJpegThumbnail = (url_1, _a) => __awaiter(void 0, [url_1, _a], void 0, function* (url, { thumbnailWidth, fetchOpts }) {
+    const stream = yield (0, messages_media_1.getHttpStream)(url, fetchOpts);
+    const result = yield (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth);
     return result;
-};
+});
 /**
  * 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
  */
-const getUrlInfo = async (text, opts = {
+const getUrlInfo = (text_1, ...args_1) => __awaiter(void 0, [text_1, ...args_1], void 0, function* (text, opts = {
     thumbnailWidth: THUMBNAIL_WIDTH_PX,
     fetchOpts: { timeout: 3000 }
-}) => {
+}) {
     var _a;
     try {
         // retries
         const retries = 0;
         const maxRetry = 5;
-        const { getLinkPreview } = await import('link-preview-js');
+        const { getLinkPreview } = yield Promise.resolve().then(() => __importStar(require('link-preview-js')));
         let previewLink = text;
         if (!text.startsWith('https://') && !text.startsWith('http://')) {
             previewLink = 'https://' + previewLink;
         }
-        const info = await getLinkPreview(previewLink, {
-            ...opts.fetchOpts,
-            followRedirects: 'manual',
-            handleRedirects: (baseURL, forwardedURL) => {
+        const info = yield getLinkPreview(previewLink, Object.assign(Object.assign({}, opts.fetchOpts), { followRedirects: 'follow', handleRedirects: (baseURL, forwardedURL) => {
                 const urlObj = new URL(baseURL);
                 const forwardedURLObj = new URL(forwardedURL);
                 if (retries >= maxRetry) {
@@ -48,9 +87,7 @@ const getUrlInfo = async (text, opts = {
                 else {
                     return false;
                 }
-            },
-            headers: opts.fetchOpts
-        });
+            }, headers: opts.fetchOpts }));
         if (info && 'title' in info && info.title) {
             const [image] = info.images;
             const urlInfo = {
@@ -61,7 +98,7 @@ const getUrlInfo = async (text, opts = {
                 originalThumbnailUrl: image
             };
             if (opts.uploadImage) {
-                const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)({ image: { url: image } }, {
+                const { imageMessage } = yield (0, messages_1.prepareWAMessageMedia)({ image: { url: image } }, {
                     upload: opts.uploadImage,
                     mediaTypeOverride: 'thumbnail-link',
                     options: opts.fetchOpts
@@ -74,7 +111,7 @@ const getUrlInfo = async (text, opts = {
             else {
                 try {
                     urlInfo.jpegThumbnail = image
-                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
+                        ? (yield getCompressedJpegThumbnail(image, opts)).buffer
                         : undefined;
                 }
                 catch (error) {
@@ -89,5 +126,5 @@ const getUrlInfo = async (text, opts = {
             throw error;
         }
     }
-};
+});
 exports.getUrlInfo = getUrlInfo;

package/src/Utils/link-preview.ts

@@ -0,0 +1,122 @@
+import { AxiosRequestConfig } from 'axios'
+import { Logger } from 'pino'
+import { WAMediaUploadFunction, WAUrlInfo } from '../Types'
+import { prepareWAMessageMedia } from './messages'
+import { extractImageThumb, getHttpStream } from './messages-media'
+
+const THUMBNAIL_WIDTH_PX = 192
+
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async(
+	url: string,
+	{ thumbnailWidth, fetchOpts }: URLGenerationOptions
+) => {
+	const stream = await getHttpStream(url, fetchOpts)
+	const result = await extractImageThumb(stream, thumbnailWidth)
+	return result
+}
+
+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 const getUrlInfo = async(
+	text: string,
+	opts: URLGenerationOptions = {
+		thumbnailWidth: THUMBNAIL_WIDTH_PX,
+		fetchOpts: { timeout: 3000 }
+	},
+): Promise<WAUrlInfo | undefined> => {
+	try {
+		// retries
+		const retries = 0
+		const maxRetry = 5
+
+		const { getLinkPreview } = await import('link-preview-js')
+		let previewLink = text
+		if(!text.startsWith('https://') && !text.startsWith('http://')) {
+			previewLink = 'https://' + previewLink
+		}
+
+		const info = await getLinkPreview(previewLink, {
+			...opts.fetchOpts,
+			followRedirects: 'follow',
+			handleRedirects: (baseURL: string, forwardedURL: string) => {
+				const urlObj = new URL(baseURL)
+				const forwardedURLObj = new URL(forwardedURL)
+				if(retries >= maxRetry) {
+					return false
+				}
+
+				if(
+					forwardedURLObj.hostname === urlObj.hostname
+					|| forwardedURLObj.hostname === 'www.' + urlObj.hostname
+					|| 'www.' + forwardedURLObj.hostname === urlObj.hostname
+				) {
+					retries + 1
+					return true
+				} else {
+					return false
+				}
+			},
+			headers: opts.fetchOpts as {}
+		})
+		if(info && 'title' in info && info.title) {
+			const [image] = info.images
+
+			const urlInfo: WAUrlInfo = {
+				'canonical-url': info.url,
+				'matched-text': text,
+				title: info.title,
+				description: info.description,
+				originalThumbnailUrl: image
+			}
+
+			if(opts.uploadImage) {
+				const { imageMessage } = await prepareWAMessageMedia(
+					{ image: { url: image } },
+					{
+						upload: opts.uploadImage,
+						mediaTypeOverride: 'thumbnail-link',
+						options: opts.fetchOpts
+					}
+				)
+				urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
+					? Buffer.from(imageMessage.jpegThumbnail)
+					: undefined
+				urlInfo.highQualityThumbnail = imageMessage || undefined
+			} else {
+				try {
+					urlInfo.jpegThumbnail = image
+						? (await getCompressedJpegThumbnail(image, opts)).buffer
+						: undefined
+				} catch(error) {
+					opts.logger?.debug(
+						{ err: error.stack, url: previewLink },
+						'error in generating thumbnail'
+					)
+				}
+			}
+
+			return urlInfo
+		}
+	} catch(error) {
+		if(!error.message.includes('receive a valid')) {
+			throw error
+		}
+	}
+}

package/src/Utils/logger.ts

@@ -0,0 +1,3 @@
+import P from 'pino'
+
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` })

package/src/Utils/lt-hash.ts

@@ -0,0 +1,61 @@
+import { hkdf } from './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 d {
+
+	salt: string
+
+	constructor(e: string) {
+		this.salt = e
+	}
+	add(e, t) {
+		var r = this
+		for(const item of t) {
+			e = r._addSingle(e, item)
+		}
+
+		return e
+	}
+	subtract(e, t) {
+		var r = this
+		for(const item of t) {
+			e = r._subtractSingle(e, item)
+		}
+
+		return e
+	}
+	subtractThenAdd(e, t, r) {
+		var n = this
+		return n.add(n.subtract(e, r), t)
+	}
+	_addSingle(e, t) {
+		var r = this
+		const n = new Uint8Array(hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+		return r.performPointwiseWithOverflow(e, n, ((e, t) => e + t))
+	}
+	_subtractSingle(e, t) {
+		var r = this
+
+		const n = new Uint8Array(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)
+		for(let e = 0; e < n.byteLength; e += 2) {
+			s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0)
+		}
+
+		return a
+	}
+}
+export const LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')

package/{lib → src}/Utils/make-mutex.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeKeyedMutex = exports.makeMutex = void 0;
 const makeMutex = () => {
@@ -6,22 +15,22 @@ const makeMutex = () => {
     let taskTimeout;
     return {
         mutex(code) {
-            task = (async () => {
+            task = (() => __awaiter(this, void 0, void 0, function* () {
                 // wait for the previous task to complete
                 // if there is an error, we swallow so as to not block the queue
                 try {
-                    await task;
+                    yield task;
                 }
                 catch (_a) { }
                 try {
                     // execute the current task
-                    const result = await code();
+                    const result = yield code();
                     return result;
                 }
                 finally {
                     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;

package/src/Utils/make-mutex.ts

@@ -0,0 +1,44 @@
+export const makeMutex = () => {
+	let task = Promise.resolve() as Promise<any>
+
+	let taskTimeout: NodeJS.Timeout | undefined
+
+	return {
+		mutex<T>(code: () => Promise<T> | T): Promise<T> {
+			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
+				} catch{ }
+
+				try {
+					// execute the current task
+					const result = await code()
+					return result
+				} finally {
+					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 type Mutex = ReturnType<typeof makeMutex>
+
+export const makeKeyedMutex = () => {
+	const map: { [id: string]: Mutex } = {}
+
+	return {
+		mutex<T>(key: string, task: () => Promise<T> | T): Promise<T> {
+			if(!map[key]) {
+				map[key] = makeMutex()
+			}
+
+			return map[key].mutex(task)
+		}
+	}
+}