@gqb333/based 2.7.71

package/lib/Utils/index.js

@@ -0,0 +1,38 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generics"), exports);
+__exportStar(require("./decode-wa-message"), exports);
+__exportStar(require("./messages"), exports);
+__exportStar(require("./messages-media"), exports);
+__exportStar(require("./validate-connection"), exports);
+__exportStar(require("./crypto"), exports);
+__exportStar(require("./signal"), exports);
+__exportStar(require("./noise-handler"), exports);
+__exportStar(require("./history"), exports);
+__exportStar(require("./chat-utils"), exports);
+__exportStar(require("./lt-hash"), exports);
+__exportStar(require("./auth-utils"), exports);
+__exportStar(require("./baileys-event-stream"), exports);
+__exportStar(require("./use-multi-file-auth-state"), exports);
+__exportStar(require("./link-preview"), exports);
+__exportStar(require("./event-buffer"), exports);
+__exportStar(require("./process-message"), exports);
+__exportStar(require("./performance-config"), exports);
+__exportStar(require("./jid-validation"), exports);
+__exportStar(require("./newsletter-utils"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./cache-manager"), exports);

package/lib/Utils/jid-validation.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidJid: (jid: string) => boolean;
+export declare const normalizeJid: (jid: string) => string;

package/lib/Utils/jid-validation.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJid = exports.toJid = exports.getSenderLid = exports.normalizeJid = exports.isValidJid = void 0;
+
+const WABinary_1 = require("../WABinary");
+const performance_config_1 = require("./performance-config");
+
+/**
+ * Check if a JID is valid
+ * @param {string} jid - The JID to validate
+ * @returns {boolean} True if valid, false otherwise
+ */
+const isValidJid = (jid) => {
+    if (!jid || typeof jid !== 'string') {
+        return false;
+    }
+
+    // Basic format validation
+    if (!jid.includes('@')) {
+        return false;
+    }
+
+    // Check for valid server domains
+    const validDomains = ['s.whatsapp.net', 'c.us', 'g.us', 'broadcast', 'lid', 'newsletter'];
+    const domain = jid.split('@')[1];
+    return validDomains.some(validDomain => domain === validDomain || domain.endsWith(validDomain));
+};
+
+exports.isValidJid = isValidJid;
+
+/**
+ * Normalize JID format
+ * @param {string} jid - The JID to normalize
+ * @returns {string} Normalized JID
+ */
+const normalizeJid = (jid) => {
+    if (!jid) return jid;
+
+    // Convert LID to standard JID format
+    if ((0, WABinary_1.isLid)(jid)) {
+        const converted = (0, WABinary_1.lidToJid)(jid);
+        return converted || jid;
+    }
+
+    // Ensure consistent format
+    return jid;
+};
+
+exports.normalizeJid = normalizeJid;
+
+/**
+ * Extract sender LID from message
+ * @param {Object} msg - The message object
+ * @returns {Object} Object containing jid, lid, and validation status
+ */
+const getSenderLid = (msg) => {
+    try {
+        if (!msg || typeof msg !== 'object') {
+            return {
+                jid: '',
+                lid: '',
+                isValid: false,
+                user: '',
+                timestamp: Date.now(),
+                error: 'Invalid message object'
+            };
+        }
+
+        // Extract from different possible fields
+        const jid = msg.key?.remoteJid || msg.remoteJid || msg.from;
+        const lid = msg.key?.participant || msg.participant || msg.lid;
+
+        if (!jid || typeof jid !== 'string') {
+            return {
+                jid: '',
+                lid: typeof lid === 'string' ? lid : '',
+                isValid: false,
+                user: '',
+                timestamp: Date.now(),
+                error: 'Missing or invalid JID'
+            };
+        }
+
+        // Validate and normalize
+        const normalizedJid = normalizeJid(jid);
+        const isValid = isValidJid(normalizedJid);
+
+        const decoded = (0, WABinary_1.jidDecode)(normalizedJid);
+        const user = decoded?.user || normalizedJid.split('@')[0] || '';
+
+        return {
+            jid: normalizedJid,
+            lid: typeof lid === 'string' ? lid : '',
+            isValid: isValid,
+            user,
+            timestamp: Date.now(),
+            ...(isValid ? {} : { error: 'Invalid JID format' })
+        };
+    } catch (error) {
+        performance_config_1.Logger.error('Error in getSenderLid:', error);
+        return {
+            jid: '',
+            lid: '',
+            isValid: false,
+            user: '',
+            timestamp: Date.now(),
+            error: 'Error extracting sender information'
+        };
+    }
+};
+
+exports.getSenderLid = getSenderLid;
+
+/**
+ * Convert LID to JID
+ * @param {string} lid - The LID to convert
+ * @returns {string} Converted JID
+ */
+const toJid = (lid) => {
+    if (!lid) return lid;
+
+    try {
+        // Convert LID to JID format
+        if ((0, WABinary_1.isLid)(lid)) {
+            const converted = (0, WABinary_1.lidToJid)(lid);
+            return converted || lid;
+        }
+
+        // If already in JID format, return as-is
+        return lid;
+    } catch (error) {
+        performance_config_1.Logger.error('Error in toJid:', error);
+        return lid;
+    }
+};
+
+exports.toJid = toJid;
+
+/**
+ * Validate JID with detailed error information
+ * @param {string} jid - The JID to validate
+ * @returns {Object} Validation result with isValid and error message
+ */
+const validateJid = (jid) => {
+    try {
+        if (!jid) {
+            return { isValid: false, error: 'JID is null or undefined' };
+        }
+
+        if (typeof jid !== 'string') {
+            return { isValid: false, error: 'JID is not a string' };
+        }
+
+        if (!jid.includes('@')) {
+            return { isValid: false, error: 'JID must contain @ character' };
+        }
+
+        const parts = jid.split('@');
+        if (parts.length !== 2) {
+            return { isValid: false, error: 'JID must have exactly one @ character' };
+        }
+
+        const [user, domain] = parts;
+        if (!user || !domain) {
+            return { isValid: false, error: 'JID must have both user and domain parts' };
+        }
+
+        // Check for valid domains
+        const validDomains = ['s.whatsapp.net', 'c.us', 'g.us', 'broadcast', 'lid', 'newsletter'];
+        const isValidDomain = validDomains.some(validDomain =>
+            domain === validDomain || domain.endsWith(validDomain)
+        );
+
+        if (!isValidDomain) {
+            return { isValid: false, error: `Invalid domain: ${domain}` };
+        }
+
+        return { isValid: true };
+
+    } catch (error) {
+        performance_config_1.Logger.error('Error in validateJid:', error);
+        return { isValid: false, error: 'Validation error: ' + error.message };
+    }
+};
+
+exports.validateJid = validateJid;

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

@@ -0,0 +1,21 @@
+import { AxiosRequestConfig } from 'axios';
+import { ILogger } from './logger';
+import { WAMediaUploadFunction, WAUrlInfo } from '../Types';
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: AxiosRequestConfig<{}>['headers'];
+    };
+    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>;

package/lib/Utils/link-preview.js

@@ -0,0 +1,152 @@
+"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;
+    };
+})();
+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 = 1200;
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts, logger }) => {
+    try {
+        const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts);
+        const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth);
+        logger?.debug({ url, thumbnailWidth }, 'Successfully generated compressed JPEG thumbnail');
+        return result;
+    } catch (error) {
+        logger?.warn({ url, thumbnailWidth, error: error.message }, 'Failed to generate compressed JPEG thumbnail, attempting fallback');
+        // Fallback to lower quality if high quality fails
+        try {
+            const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts);
+            const result = await (0, messages_media_1.extractImageThumb)(stream, Math.min(thumbnailWidth, 512));
+            logger?.debug({ url, fallbackWidth: Math.min(thumbnailWidth, 512) }, 'Successfully generated fallback thumbnail');
+            return result;
+        } catch (fallbackError) {
+            logger?.error({ url, error: fallbackError.message }, 'Failed to generate fallback thumbnail');
+            throw fallbackError;
+        }
+    }
+};
+/**
+ * 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 = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    var _a;
+    try {
+        const { unfurl } = await Promise.resolve().then(() => __importStar(require('unfurl.js')));
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const requestHeaders = (() => {
+            const headers = opts.fetchOpts?.headers;
+            if (!headers || typeof headers !== 'object') {
+                return undefined;
+            }
+            const out = {};
+            for (const [key, value] of Object.entries(headers)) {
+                if (typeof value === 'undefined' || value === null) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    out[key] = value.map(v => v.toString()).join(', ');
+                }
+                else {
+                    out[key] = value.toString();
+                }
+            }
+            return out;
+        })();
+        const info = await unfurl(previewLink, {
+            timeout: opts.fetchOpts?.timeout,
+            headers: requestHeaders,
+            follow: 5
+        });
+        const title = info?.title || info?.open_graph?.title || info?.twitter_card?.title;
+        if (title) {
+            const images = [];
+            if (info?.open_graph?.images?.length) {
+                images.push(...info.open_graph.images.map(img => img === null || img === void 0 ? void 0 : img.url).filter(Boolean));
+            }
+            if (info?.twitter_card?.images?.length) {
+                images.push(...info.twitter_card.images.map(img => img === null || img === void 0 ? void 0 : img.url).filter(Boolean));
+            }
+            const [image] = images;
+            const description = info?.description || info?.open_graph?.description || info?.twitter_card?.description;
+            const canonicalUrl = info?.canonical_url || info?.open_graph?.url || previewLink;
+            opts.logger?.debug({ url: previewLink, title, imageCount: images.length }, 'Fetched link preview info');
+            const urlInfo = {
+                'canonical-url': canonicalUrl,
+                'matched-text': text,
+                title,
+                description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage && image) {
+                const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = (imageMessage === null || imageMessage === void 0 ? void 0 : imageMessage.jpegThumbnail)
+                    ? Buffer.from(imageMessage.jpegThumbnail)
+                    : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image
+                        ? (await getCompressedJpegThumbnail(image, { ...opts, logger: opts.logger })).buffer
+                        : undefined;
+                }
+                catch (error) {
+                    (_a = opts.logger) === null || _a === void 0 ? void 0 : _a.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid') && !error.message.includes('Invalid URL')) {
+            throw error;
+        }
+    }
+};
+exports.getUrlInfo = getUrlInfo;

package/lib/Utils/logger.d.ts

@@ -0,0 +1,11 @@
+export interface ILogger {
+    level: string;
+    child(obj: Record<string, unknown>): ILogger;
+    trace(obj: unknown, msg?: string): any;
+    debug(obj: unknown, msg?: string): any;
+    info(obj: unknown, msg?: string): any;
+    warn(obj: unknown, msg?: string): any;
+    error(obj: unknown, msg?: string): any;
+}
+declare const _default: import("pino").Logger<never, boolean>;
+export default _default;

package/lib/Utils/logger.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino_1 = __importDefault(require("pino"));
+const { getPerformanceConfig } = require('./performance-config');
+const defaultLogger = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+class EnhancedLogger {
+    constructor() {
+        this.config = getPerformanceConfig();
+    }
+
+    static error(...args) {
+        if (defaultLogger.isLevelEnabled('error')) {
+            defaultLogger.error(...args);
+        }
+        // Additional error tracking if enabled
+        if (this.config?.debug?.enableErrorTracking) {
+            // Could send to external monitoring service
+            console.error('[ERROR TRACK]', ...args);
+        }
+    }
+
+    static warn(...args) {
+        if (defaultLogger.isLevelEnabled('warn')) {
+            defaultLogger.warn(...args);
+        }
+    }
+
+    static info(...args) {
+        if (this.config?.debug?.enableInfoLogging && defaultLogger.isLevelEnabled('info')) {
+            defaultLogger.info(...args);
+        }
+    }
+
+    static debug(...args) {
+        if (this.config?.debug?.enableDebugLogging && defaultLogger.isLevelEnabled('debug')) {
+            defaultLogger.debug(...args);
+        }
+    }
+    static createBaileysLogger(level = 'info', prefix = 'Based') {
+        return {
+            level,
+            debug: (...args) => this.debug(`[${prefix}]`, ...args),
+            info: (...args) => this.info(`[${prefix}]`, ...args),
+            warn: (...args) => this.warn(`[${prefix}]`, ...args),
+            error: (...args) => this.error(`[${prefix}]`, ...args),
+            trace: (...args) => this.debug(`[${prefix} TRACE]`, ...args),
+            child: (bindings) => ({
+                ...this.createBaileysLogger(level, prefix),
+                bindings
+            })
+        };
+    }
+}
+
+exports.EnhancedLogger = EnhancedLogger;
+exports.default = defaultLogger;

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

@@ -0,0 +1,12 @@
+declare class d {
+    salt: string;
+    constructor(e: string);
+    add(e: any, t: any): any;
+    subtract(e: any, t: any): any;
+    subtractThenAdd(e: any, t: any, r: any): any;
+    _addSingle(e: any, t: any): Promise<ArrayBuffer>;
+    _subtractSingle(e: any, t: any): Promise<ArrayBuffer>;
+    performPointwiseWithOverflow(e: any, t: any, r: any): ArrayBuffer;
+}
+export declare const LT_HASH_ANTI_TAMPERING: d;
+export {};

package/lib/Utils/lt-hash.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LT_HASH_ANTI_TAMPERING = void 0;
+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 d {
+    constructor(e) {
+        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);
+    }
+    async _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));
+    }
+    async _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));
+    }
+    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;
+    }
+}
+exports.LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity');

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

@@ -0,0 +1,7 @@
+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>;
+};

package/lib/Utils/make-mutex.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyedMutex = exports.makeMutex = void 0;
+const makeMutex = () => {
+    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;
+                }
+                catch (_a) { }
+                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;
+        },
+    };
+};
+exports.makeMutex = makeMutex;
+const makeKeyedMutex = () => {
+    const map = {};
+    return {
+        mutex(key, task) {
+            if (!map[key]) {
+                map[key] = (0, exports.makeMutex)();
+            }
+            return map[key].mutex(task);
+        }
+    };
+};
+exports.makeKeyedMutex = makeKeyedMutex;