@realvare/based 2.7.61 → 2.7.70

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, 1031424117]
 }

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;

package/lib/Defaults/index.js

@@ -25,11 +25,11 @@ 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,

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);
@@ -367,14 +369,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 +468,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) {
@@ -499,24 +513,40 @@ const makeChatsSocket = (config) => {
     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;
             }
             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 +558,7 @@ const makeChatsSocket = (config) => {
                         attrs: type === 'recording' ? { media: 'audio' } : {}
                     }
                 ]
-            });
+            }), retryOptions);
         }
     };
     /**
@@ -754,22 +784,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 });

package/lib/Socket/groups.js

@@ -6,6 +6,8 @@ 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;
@@ -25,16 +27,41 @@ 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();
+
+        // Check cache first
+        const cached = CacheManager.get('groupMetadataCache', jid);
+        if (cached) {
+            config.logger?.trace({ jid }, 'using cached group metadata');
+            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);
+
+                // 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;
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -79,6 +106,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 +383,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 +392,4 @@ const extractGroupMetadata = (result) => {
     };
     return metadata;
 };
-exports.extractGroupMetadata = extractGroupMetadata;
+exports.extractGroupMetadata = extractGroupMetadata;