@realvare/based 2.7.62 → 2.7.71

package/engine-requirements.js

@@ -1,10 +1,10 @@
-const major = parseInt(process.versions.node.split('.')[0], 10);
-
-if (major < 20) {
-  console.error(
-    `\n❌ This package requires Node.js 20+ to run reliably.\n` +
-    `   You are using Node.js ${process.versions.node}.\n` +
-    `   Please upgrade to Node.js 20+ to proceed.\n`
-  );
-  process.exit(1);
-}
+const major = parseInt(process.versions.node.split('.')[0], 10);
+
+if (major < 20) {
+  console.error(
+    `\n❌ This package requires Node.js 20+ to run reliably.\n` +
+    `   You are using Node.js ${process.versions.node}.\n` +
+    `   Please upgrade to Node.js 20+ to proceed.\n`
+  );
+  process.exit(1);
+}

package/lib/Defaults/baileys-version.json

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

package/lib/Defaults/index.d.ts

@@ -15,7 +15,7 @@ export declare const URL_REGEX: RegExp;
 export declare const WA_CERT_DETAILS: {
     SERIAL: number;
 };
-export declare const PROCESSABLE_HISTORY_TYPES: proto.Message.HistorySyncNotification.HistorySyncType[];
+export declare const PROCESSABLE_HISTORY_TYPES: proto.Message.HistorySyncType[];
 export declare const DEFAULT_CONNECTION_CONFIG: SocketConfig;
 export declare const MEDIA_PATH_MAP: {
     [T in MediaType]?: string;
@@ -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,18 +18,18 @@ 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 = {
     SERIAL: 0,
 };
 exports.PROCESSABLE_HISTORY_TYPES = [
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_BOOTSTRAP,
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.PUSH_NAME,
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.RECENT,
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL,
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND,
+    WAProto_1.proto.Message.HistorySyncType.INITIAL_BOOTSTRAP,
+    WAProto_1.proto.Message.HistorySyncType.PUSH_NAME,
+    WAProto_1.proto.Message.HistorySyncType.RECENT,
+    WAProto_1.proto.Message.HistorySyncType.FULL,
+    WAProto_1.proto.Message.HistorySyncType.ON_DEMAND,
 ];
 exports.DEFAULT_CONNECTION_CONFIG = {
     version: baileys_version_json_1.version,
@@ -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

@@ -15,7 +15,9 @@ const process_message_1 = __importDefault(require("../Utils/process-message"));
 const WABinary_1 = require("../WABinary");
 const WAUSync_1 = require("../WAUSync");
 const usync_1 = require("./usync");
+const retry_1 = require("../Utils/retry");
 const MAX_SYNC_ATTEMPTS = 2;
+const APP_STATE_RESYNC_COOLDOWN_MS = 60000;
 const makeChatsSocket = (config) => {
     const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config;
     const sock = (0, usync_1.makeUSyncSocket)(config);
@@ -23,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({
@@ -32,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]);
@@ -293,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;
@@ -367,14 +478,23 @@ const makeChatsSocket = (config) => {
             }
         };
     };
+    const appStateResyncCooldown = new Map();
     const resyncAppState = ev.createBufferedFunction(async (collections, isInitialSync) => {
+        const now = Date.now();
+        const collectionsToSync = collections.filter(name => {
+            const until = appStateResyncCooldown.get(name) || 0;
+            return until <= now;
+        });
+        if (!collectionsToSync.length) {
+            return;
+        }
         // we use this to determine which events to fire
         // otherwise when we resync from scratch -- all notifications will fire
         const initialVersionMap = {};
         const globalMutationMap = {};
         await authState.keys.transaction(async () => {
             var _a;
-            const collectionsToHandle = new Set(collections);
+            const collectionsToHandle = new Set(collectionsToSync);
             // in case something goes wrong -- ensure we don't enter a loop that cannot be exited from
             const attemptsMap = {};
             // keep executing till all collections are done
@@ -457,6 +577,9 @@ const makeChatsSocket = (config) => {
                             || error.name === 'TypeError';
                         logger.info({ name, error: error.stack }, `failed to sync state from version${isIrrecoverableError ? '' : ', removing and trying from scratch'}`);
                         await authState.keys.set({ 'app-state-sync-version': { [name]: null } });
+                        if (((_a = error.output) === null || _a === void 0 ? void 0 : _a.statusCode) === 404) {
+                            appStateResyncCooldown.set(name, Date.now() + APP_STATE_RESYNC_COOLDOWN_MS);
+                        }
                         // increment number of retries
                         attemptsMap[name] = (attemptsMap[name] || 0) + 1;
                         if (isIrrecoverableError) {
@@ -481,42 +604,86 @@ 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);
         const me = authState.creds.me;
+        const retryOptions = {
+            retries: 2,
+            baseMs: 1000,
+            maxMs: 5000,
+            jitter: true,
+            timeoutPerAttemptMs: 10000,
+            shouldRetry: (err) => {
+                if (err.message.includes('WebSocket is not open')) {
+                    return false;
+                }
+                var _a;
+                const status = ((_a = err.output) === null || _a === void 0 ? void 0 : _a.statusCode) || (err === null || err === void 0 ? void 0 : err.statusCode);
+                return !status || (status >= 500 || status === 408 || status === 429);
+            },
+            onRetry: (err, n) => logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt: n }, 'retrying presence update')
+        };
         if (type === 'available' || type === 'unavailable') {
             if (!me.name) {
                 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 sendNode({
+            await (0, retry_1.retryWithBackoff)(() => sendNode({
                 tag: 'presence',
                 attrs: {
                     name: me.name.replace(/@/g, ''),
                     type
                 }
-            });
+            }), retryOptions);
         }
         else {
             const { server } = (0, WABinary_1.jidDecode)(toJid);
             const isLid = server === 'lid';
-            await sendNode({
+            await (0, retry_1.retryWithBackoff)(() => sendNode({
                 tag: 'chatstate',
                 attrs: {
                     from: isLid ? me.lid : me.id,
@@ -528,7 +695,7 @@ const makeChatsSocket = (config) => {
                         attrs: type === 'recording' ? { media: 'audio' } : {}
                     }
                 ]
-            });
+            }), retryOptions);
         }
     };
     /**
@@ -754,22 +921,29 @@ const makeChatsSocket = (config) => {
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
         var _a, _b, _c;
         try {
-            const r = msg?.key?.remoteJid;
-            const p = msg?.key?.participant;
-            if (r) {
-                const rd = (0, WABinary_1.jidDecode)(r);
+            const r0 = msg?.key?.remoteJid;
+            const p0 = msg?.key?.participant;
+
+            if (r0) {
+                const rd = (0, WABinary_1.jidDecode)(r0);
                 if (rd?.user) {
-                    const lid = (0, WABinary_1.jidEncode)(rd.user, 'lid');
-                    msg.key.remoteLid = lid;
-                    msg.key.remoteJidNormalized = (0, WABinary_1.jidNormalizedUser)(r);
+                    // preserve LID form (original if provided, otherwise derived)
+                    msg.key.remoteLid = (0, WABinary_1.isLid)(r0) ? r0 : (0, WABinary_1.jidEncode)(rd.user, 'lid');
                 }
+                // always expose a standard jid to consumers
+                msg.key.remoteJid = (0, WABinary_1.jidNormalizedUser)((0, WABinary_1.lidToJid)(r0));
+                msg.key.remoteJidNormalized = msg.key.remoteJid;
             }
-            if (p) {
-                const pd = (0, WABinary_1.jidDecode)(p);
+
+            if (p0) {
+                const pd = (0, WABinary_1.jidDecode)(p0);
                 if (pd?.user) {
-                    const lidP = (0, WABinary_1.jidEncode)(pd.user, 'lid');
-                    msg.key.participantLid = lidP;
+                    msg.key.participantLid = (0, WABinary_1.isLid)(p0) ? p0 : (0, WABinary_1.jidEncode)(pd.user, 'lid');
                 }
+                msg.key.participant = (0, WABinary_1.jidNormalizedUser)((0, WABinary_1.lidToJid)(p0));
+            }
+            if (msg === null || msg === void 0 ? void 0 : msg.participant) {
+                msg.participant = (0, WABinary_1.jidNormalizedUser)((0, WABinary_1.lidToJid)(msg.participant));
             }
         } catch {}
         ev.emit('messages.upsert', { messages: [msg], type });
@@ -894,6 +1068,9 @@ const makeChatsSocket = (config) => {
         updateProfileStatus,
         updateProfileName,
         updateBlockStatus,
+        reportUser,
+        reportMessage,
+        reportAndBlockUser,
         updateCallPrivacy,
         updateMessagesPrivacy,
         updateLastSeenPrivacy,

package/lib/Socket/groups.js

@@ -6,15 +6,14 @@ const Types_1 = require("../Types");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
 const chats_1 = require("./chats");
+const { getPerformanceConfig } = require('../Utils/performance-config');
+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: {
@@ -25,16 +24,72 @@ const makeGroupsSocket = (config) => {
         content
     }));
     const groupMetadata = async (jid) => {
-        const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-        const metadata = (0, exports.extractGroupMetadata)(result);
-        if (config.lidCache) {
-            for (const p of metadata.participants) {
-                if ((0, WABinary_1.isLid)(p.id) && !(0, WABinary_1.isLid)(p.jid)) {
-                    config.lidCache.set(p.id, p.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) {
+            config.logger?.trace({ jid }, 'using cached group metadata');
+            return cached;
+        }
+
+        // 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);
+
+                    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);
         }
-        return metadata;
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -79,6 +134,23 @@ const makeGroupsSocket = (config) => {
         await groupFetchAllParticipating();
         await sock.cleanDirtyBits('groups');
     });
+
+    // Cache invalidation on group events
+    ev.on('groups.update', async (groups) => {
+        for (const group of groups) {
+            CacheManager.del('groupMetadataCache', group.id);
+        }
+    });
+
+    ev.on('group-participants.update', async (update) => {
+        CacheManager.del('groupMetadataCache', update.id);
+    });
+
+    ev.on('groups.upsert', async (groups) => {
+        for (const group of groups) {
+            CacheManager.del('groupMetadataCache', group.id);
+        }
+    });
     return {
         ...sock,
         groupQuery,
@@ -339,7 +411,7 @@ const extractGroupMetadata = (result) => {
         participants: (0, WABinary_1.getBinaryNodeChildren)(group, 'participant').map(({ attrs }) => {
             return {
                 id: attrs.jid,
-                jid: attrs.phone_number || attrs.jid,
+                jid: attrs.phone_number || (0, WABinary_1.lidToJid)(attrs.jid),
                 lid: attrs.lid || ((0, WABinary_1.isLid)(attrs.jid) ? attrs.jid : undefined),
                 admin: (attrs.type || null),
             };
@@ -348,4 +420,4 @@ const extractGroupMetadata = (result) => {
     };
     return metadata;
 };
-exports.extractGroupMetadata = extractGroupMetadata;
+exports.extractGroupMetadata = extractGroupMetadata;

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,