@realvare/based 2.7.70 → 2.7.71

package/lib/Defaults/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 3000, 1031424117]
+    "version": [2, 3000, 1032094433]
 }

package/lib/Defaults/index.d.ts

@@ -48,4 +48,6 @@ export declare const DEFAULT_CACHE_TTLS: {
     MSG_RETRY: number;
     CALL_OFFER: number;
     USER_DEVICES: number;
-};
+    LID_JID: number;
+    PROFILE_PIC: number;
+};

package/lib/Defaults/index.js

@@ -18,7 +18,7 @@ exports.WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
 exports.NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
 exports.DICT_VERSION = 3;
 exports.KEY_BUNDLE_TYPE = Buffer.from([5]);
-exports.NOISE_WA_HEADER = Buffer.from([87, 65, 6, exports.DICT_VERSION]); // last isambasedd "DICT_VERSION"
+exports.NOISE_WA_HEADER = Buffer.from([87, 65, 6, exports.DICT_VERSION]); // last is "DICT_VERSION"
 /** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
 exports.URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
 exports.WA_CERT_DETAILS = {
@@ -103,4 +103,6 @@ exports.DEFAULT_CACHE_TTLS = {
     MSG_RETRY: 60 * 60, // 1 hour
     CALL_OFFER: 5 * 60, // 5 minutes
     USER_DEVICES: 5 * 60, // 5 minutes
+    LID_JID: 5 * 60, // 5 minutes
+    PROFILE_PIC: 60 * 60, // 1 hour
 };

package/lib/Signal/Group/ciphertext-message.d.ts

@@ -6,4 +6,4 @@ export declare class CiphertextMessage {
     readonly SENDERKEY_TYPE: number;
     readonly SENDERKEY_DISTRIBUTION_TYPE: number;
     readonly ENCRYPTED_MESSAGE_OVERHEAD: number;
-}
+}

package/lib/Signal/Group/ciphertext-message.js

@@ -12,4 +12,4 @@ class CiphertextMessage {
         this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
     }
 }
-exports.CiphertextMessage = CiphertextMessage;
+exports.CiphertextMessage = CiphertextMessage;

package/lib/Signal/Group/sender-message-key.d.ts

@@ -8,4 +8,4 @@ export declare class SenderMessageKey {
     getIv(): Uint8Array;
     getCipherKey(): Uint8Array;
     getSeed(): Uint8Array;
-}
+}

package/lib/Signal/Group/sender-message-key.js

@@ -26,4 +26,4 @@ class SenderMessageKey {
         return this.seed;
     }
 }
-exports.SenderMessageKey = SenderMessageKey;
+exports.SenderMessageKey = SenderMessageKey;

package/lib/Signal/libsignal.d.ts

@@ -1,3 +1,3 @@
 import { SignalAuthState } from '../Types';
 import { SignalRepository } from '../Types/Signal';
-export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Socket/business.d.ts

@@ -169,4 +169,4 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     requestPairingCode: (phoneNumber: any, pairKey?: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
-};
+};

package/lib/Socket/business.js

@@ -257,4 +257,4 @@ const makeBusinessSocket = (config) => {
         productUpdate
     };
 };
-exports.makeBusinessSocket = makeBusinessSocket;
+exports.makeBusinessSocket = makeBusinessSocket;

package/lib/Socket/chats.d.ts

@@ -28,6 +28,9 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     updateProfileStatus: (status: string) => Promise<void>;
     updateProfileName: (name: string) => Promise<void>;
     updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
+    reportUser: (jid: string, reason?: "spam" | "harassment" | "impersonation" | "scam" | "other", waitForAckMs?: number) => Promise<boolean>;
+    reportMessage: (jid: string, messageId: string, reason?: "spam" | "harassment" | "impersonation" | "scam" | "other", participantJid?: string, waitForAckMs?: number) => Promise<boolean>;
+    reportAndBlockUser: (jid: string, reason?: "spam" | "harassment" | "impersonation" | "scam" | "other", waitForAckMs?: number) => Promise<boolean>;
     updateCallPrivacy: (value: WAPrivacyCallValue) => Promise<void>;
     updateMessagesPrivacy: (value: WAPrivacyMessagesValue) => Promise<void>;
     updateLastSeenPrivacy: (value: WAPrivacyValue) => Promise<void>;
@@ -79,4 +82,4 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     requestPairingCode: (phoneNumber: any, pairKey?: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
-};
+};

package/lib/Socket/chats.js

@@ -25,6 +25,8 @@ const makeChatsSocket = (config) => {
     let privacySettings;
     let needToFlushWithAppStateSync = false;
     let pendingAppStateSync = false;
+    let lastSelfPresenceType;
+    let lastSelfPresenceTs = 0;
     /** this mutex ensures that the notifications (receipts, messages etc.) are processed in order */
     const processingMutex = (0, make_mutex_1.makeMutex)();
     const placeholderResendCache = config.placeholderResendCache || new node_cache_1.default({
@@ -34,12 +36,15 @@ const makeChatsSocket = (config) => {
     if (!config.placeholderResendCache) {
         config.placeholderResendCache = placeholderResendCache;
     }
-    const resolveJid = (jid) => {
-        if (typeof jid === 'string' && jid.endsWith('@lid')) {
-            return (0, WABinary_1.lidToJid)(jid);
-        }
-        return jid;
-    };
+    const profilePictureUrlCache = config.profilePictureUrlCache || new node_cache_1.default({
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.PROFILE_PIC,
+        useClones: false
+    });
+    if (!config.profilePictureUrlCache) {
+        config.profilePictureUrlCache = profilePictureUrlCache;
+    }
+    const inFlightProfilePictureUrl = new Map();
+    const resolveJid = WABinary_1.resolveJid;
     /** helper function to fetch the given app state sync key */
     const getAppStateSyncKey = async (keyId) => {
         const { [keyId]: key } = await authState.keys.get('app-state-sync-key', [keyId]);
@@ -295,6 +300,110 @@ const makeChatsSocket = (config) => {
             ]
         });
     };
+    const reportUser = async (jid, reason = 'spam', waitForAckMs = 5000) => {
+        jid = resolveJid(jid);
+        const reasonCodes = {
+            'spam': 1,
+            'harassment': 2,
+            'impersonation': 3,
+            'scam': 4,
+            'other': 5
+        };
+        const reasonCode = reasonCodes[reason] || 1;
+        const reportTo = WABinary_1.S_WHATSAPP_NET.replace(/^@/, '');
+        const node = {
+            tag: 'iq',
+            attrs: {
+                id: generateMessageTag(),
+                xmlns: 'w:report',
+                to: reportTo,
+                type: 'set'
+            },
+            content: [
+                {
+                    tag: 'user',
+                    attrs: {
+                        jid,
+                        reason: reasonCode.toString()
+                    }
+                }
+            ]
+        };
+        logger.debug({ node }, 'sending report user node');
+        try {
+            await query(node, waitForAckMs);
+            logger.info({ jid, reason }, 'reported user (ack received)');
+            return true;
+        }
+        catch (err) {
+            const statusCode = err?.output?.statusCode || err?.statusCode;
+            const isTimeout = statusCode === 408 || (err?.message && err.message.toLowerCase().includes('timed out'));
+            if (isTimeout) {
+                logger.warn({ jid, reason }, 'reported user (no ack; request likely sent)');
+                return false;
+            }
+            throw err;
+        }
+    };
+    const reportMessage = async (jid, messageId, reason = 'spam', participantJid, waitForAckMs = 5000) => {
+        jid = resolveJid(jid);
+        if (participantJid) {
+            participantJid = resolveJid(participantJid);
+        }
+        const reasonCodes = {
+            'spam': 1,
+            'harassment': 2,
+            'impersonation': 3,
+            'scam': 4,
+            'other': 5
+        };
+        const reasonCode = reasonCodes[reason] || 1;
+        const reportTo = WABinary_1.S_WHATSAPP_NET.replace(/^@/, '');
+        const msgAttrs = {
+            id: messageId,
+            reason: reasonCode.toString()
+        };
+        if (participantJid) {
+            msgAttrs.participant = participantJid;
+        }
+        const node = {
+            tag: 'iq',
+            attrs: {
+                id: generateMessageTag(),
+                xmlns: 'w:report',
+                to: reportTo,
+                type: 'set'
+            },
+            content: [
+                {
+                    tag: 'message',
+                    attrs: msgAttrs
+                }
+            ]
+        };
+        logger.debug({ node }, 'sending report message node');
+        try {
+            await query(node, waitForAckMs);
+            logger.info({ jid, messageId, reason, participantJid }, 'reported message (ack received)');
+            return true;
+        }
+        catch (err) {
+            const statusCode = err?.output?.statusCode || err?.statusCode;
+            const isTimeout = statusCode === 408 || (err?.message && err.message.toLowerCase().includes('timed out'));
+            if (isTimeout) {
+                logger.warn({ jid, messageId, reason, participantJid }, 'reported message (no ack; request likely sent)');
+                return false;
+            }
+            throw err;
+        }
+    };
+    const reportAndBlockUser = async (jid, reason = 'spam', waitForAckMs = 5000) => {
+        jid = resolveJid(jid);
+        const ack = await reportUser(jid, reason, waitForAckMs);
+        await updateBlockStatus(jid, 'block');
+        logger.info({ jid, reason, ack }, 'reported and blocked user');
+        return ack;
+    };
     const getBusinessProfile = async (jid) => {
         jid = resolveJid(jid);
         var _a, _b, _c, _d, _e, _f, _g;
@@ -495,20 +604,40 @@ const makeChatsSocket = (config) => {
         jid = resolveJid(jid);
         var _a;
         jid = (0, WABinary_1.jidNormalizedUser)(jid);
-        const result = await query({
-            tag: 'iq',
-            attrs: {
-                target: jid,
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'w:profile:picture'
-            },
-            content: [
-                { tag: 'picture', attrs: { type, query: 'url' } }
-            ]
-        }, timeoutMs);
-        const child = (0, WABinary_1.getBinaryNodeChild)(result, 'picture');
-        return (_a = child === null || child === void 0 ? void 0 : child.attrs) === null || _a === void 0 ? void 0 : _a.url;
+        const cacheKey = `${jid}:${type}`;
+        const cached = profilePictureUrlCache.get(cacheKey);
+        if (typeof cached !== 'undefined') {
+            return cached || undefined;
+        }
+        const inFlight = inFlightProfilePictureUrl.get(cacheKey);
+        if (inFlight) {
+            return inFlight;
+        }
+        const fetchPromise = (async () => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    target: jid,
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'w:profile:picture'
+                },
+                content: [
+                    { tag: 'picture', attrs: { type, query: 'url' } }
+                ]
+            }, timeoutMs);
+            const child = (0, WABinary_1.getBinaryNodeChild)(result, 'picture');
+            const url = (_a = child === null || child === void 0 ? void 0 : child.attrs) === null || _a === void 0 ? void 0 : _a.url;
+            profilePictureUrlCache.set(cacheKey, url || null);
+            return url;
+        })();
+        inFlightProfilePictureUrl.set(cacheKey, fetchPromise);
+        try {
+            return await fetchPromise;
+        }
+        finally {
+            inFlightProfilePictureUrl.delete(cacheKey);
+        }
     };
     const sendPresenceUpdate = async (type, toJid) => {
         toJid = resolveJid(toJid);
@@ -534,6 +663,14 @@ const makeChatsSocket = (config) => {
                 logger.warn('no name present, ignoring presence update request...');
                 return;
             }
+            if (!toJid) {
+                const now = Date.now();
+                if (lastSelfPresenceType === type && (now - lastSelfPresenceTs) < 3000) {
+                    return;
+                }
+                lastSelfPresenceType = type;
+                lastSelfPresenceTs = now;
+            }
             ev.emit('connection.update', { isOnline: type === 'available' });
             await (0, retry_1.retryWithBackoff)(() => sendNode({
                 tag: 'presence',
@@ -931,6 +1068,9 @@ const makeChatsSocket = (config) => {
         updateProfileStatus,
         updateProfileName,
         updateBlockStatus,
+        reportUser,
+        reportMessage,
+        reportAndBlockUser,
         updateCallPrivacy,
         updateMessagesPrivacy,
         updateLastSeenPrivacy,

package/lib/Socket/groups.js

@@ -11,12 +11,9 @@ const { CacheManager } = require('../Utils/cache-manager');
 const makeGroupsSocket = (config) => {
     const sock = (0, chats_1.makeChatsSocket)(config);
     const { authState, ev, query, upsertMessage } = sock;
-    const resolveJid = (jid) => {
-        if (typeof jid === 'string' && jid.endsWith('@lid')) {
-            return (0, WABinary_1.lidToJid)(jid);
-        }
-        return jid;
-    };
+    const inFlightGroupMetadata = new Map();
+    const forbiddenGroupMetadataUntil = new Map();
+    const resolveJid = WABinary_1.resolveJid;
     const groupQuery = async (jid, type, content) => (query({
         tag: 'iq',
         attrs: {
@@ -29,6 +26,16 @@ const makeGroupsSocket = (config) => {
     const groupMetadata = async (jid) => {
         const config = getPerformanceConfig();
 
+        const forbiddenUntil = forbiddenGroupMetadataUntil.get(jid);
+        if (forbiddenUntil && forbiddenUntil > Date.now()) {
+            const err = new Error('forbidden');
+            err.data = 403;
+            throw err;
+        }
+        else if (forbiddenUntil) {
+            forbiddenGroupMetadataUntil.delete(jid);
+        }
+
         // Check cache first
         const cached = CacheManager.get('groupMetadataCache', jid);
         if (cached) {
@@ -36,31 +43,52 @@ const makeGroupsSocket = (config) => {
             return cached;
         }
 
-        // Fetch from server with rate limiting and retry logic
-        let retryCount = 0;
-        const maxRetries = 3;
-        const baseDelay = 1000; // 1 second
-        
-        while (retryCount <= maxRetries) {
-            try {
-                const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-                const metadata = (0, exports.extractGroupMetadata)(result);
+        // If a fetch is already in progress for this group, reuse it
+        const inFlight = inFlightGroupMetadata.get(jid);
+        if (inFlight) {
+            return inFlight;
+        }
+
+        const fetchPromise = (async () => {
+            // Fetch from server with rate limiting and retry logic
+            let retryCount = 0;
+            const maxRetries = 3;
+            const baseDelay = 1000; // 1 second
+            
+            while (retryCount <= maxRetries) {
+                try {
+                    const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+                    const metadata = (0, exports.extractGroupMetadata)(result);
 
-                // Cache the result
-                CacheManager.set('groupMetadataCache', jid, metadata, config.cache.groupMetadataCache.ttl);
+                    // Cache the result
+                    CacheManager.set('groupMetadataCache', jid, metadata, config.cache.groupMetadataCache.ttl);
 
-                return metadata;
-            } catch (error) {
-                if (error.message === 'rate-overlimit' && retryCount < maxRetries) {
-                    const delay = baseDelay * Math.pow(2, retryCount); // Exponential backoff
-                    config.logger?.warn({ jid, retryCount, delay }, 'Rate limit hit, retrying group metadata fetch');
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                    retryCount++;
-                } else {
-                    // Re-throw non-rate-limit errors or if max retries exceeded
-                    throw error;
+                    return metadata;
+                } catch (error) {
+                    const statusCode = error?.output?.statusCode || error?.data;
+                    if (statusCode === 403 || error?.message === 'forbidden') {
+                        const cooldownMs = 5 * 60 * 1000;
+                        forbiddenGroupMetadataUntil.set(jid, Date.now() + cooldownMs);
+                        throw error;
+                    }
+                    if (error.message === 'rate-overlimit' && retryCount < maxRetries) {
+                        const delay = baseDelay * Math.pow(2, retryCount); // Exponential backoff
+                        config.logger?.warn({ jid, retryCount, delay }, 'Rate limit hit, retrying group metadata fetch');
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                        retryCount++;
+                    } else {
+                        // Re-throw non-rate-limit errors or if max retries exceeded
+                        throw error;
+                    }
                 }
             }
+        })();
+
+        inFlightGroupMetadata.set(jid, fetchPromise);
+        try {
+            return await fetchPromise;
+        } finally {
+            inFlightGroupMetadata.delete(jid);
         }
     };
     const groupFetchAllParticipating = async () => {

package/lib/Socket/index.js

@@ -8,10 +8,19 @@ const Defaults_1 = require("../Defaults");
 const business_1 = require("./business");
 // export the last socket layer
 const makeWASocket = (config) => {
+    const inputConfig = config;
+    const hasBrowserOverride = Object.prototype.hasOwnProperty.call(inputConfig, 'browser');
     config = {
         ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
         ...config,
     };
+    const creds = config.auth?.creds;
+    if (!hasBrowserOverride && creds?.browser) {
+        config.browser = creds.browser;
+    }
+    else if (creds && !creds.browser) {
+        creds.browser = config.browser;
+    }
     if (!config.lidCache) {
         config.lidCache = new node_cache_1.default({
             stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.LID_JID,