@realvare/based 2.7.62 → 2.7.71

package/lib/Utils/performance-config.d.ts

@@ -36,6 +36,7 @@ export interface PerformanceConfigInterface {
         lidCache: CacheConfig;
         jidCache: CacheConfig;
         lidToJidCache: CacheConfig;
+        groupMetadataCache: CacheConfig;
     };
     performance: PerformanceSettings;
     debug: DebugSettings;
@@ -46,6 +47,7 @@ export declare class PerformanceConfig implements PerformanceConfigInterface {
         lidCache: CacheConfig;
         jidCache: CacheConfig;
         lidToJidCache: CacheConfig;
+        groupMetadataCache: CacheConfig;
     };
     performance: PerformanceSettings;
     debug: DebugSettings;

package/lib/Utils/performance-config.js

@@ -35,18 +35,26 @@ class PerformanceConfig {
             enableLogging: false,
             enableMetrics: true,
             batchSize: 50,
-            maxRetries: 5,
-            retryDelay: 5000,
+            maxRetries: 3, // Reduced from 5
+            retryDelay: 2000, // Reduced from 5000
             retryBackoffMultiplier: 1.5,
-            maxRetryDelay: 60000,
-            maxMsgRetryCount: 3,
+            maxRetryDelay: 30000, // Reduced from 60000
+            maxMsgRetryCount: 2, // Reduced from 3
             memoryThreshold: 0.85,
             markOnlineOnConnect: false,
             syncFullHistory: false,
             keepAliveIntervalMs: 30000,
             enableNativeLidCache: true,
             enableLidLogging: process.env.DEBUG_LID === 'true',
-            logLevel: process.env.LOG_LEVEL || 'debug'
+            logLevel: process.env.LOG_LEVEL || 'debug',
+            // Performance optimizations
+            enableMessageBatching: true,
+            messageBatchSize: 10,
+            messageBatchTimeout: 100,
+            enableParallelProcessing: true,
+            maxConcurrentMessages: 5,
+            enableFastAck: true,
+            reduceSyncValidation: true
         };
 
         this.debug = {
@@ -63,11 +71,12 @@ class PerformanceConfig {
             },
             antiBan: {
                 enabled: true,
-                maxConsecutiveErrors: 3,
-                cooldownPeriod: 30000
+                maxConsecutiveErrors: 5,
+                cooldownPeriod: 15000
             }
         };
     }
+    
 
     /**
      * Aggiorna configurazione cache

package/lib/Utils/process-message.js

@@ -18,24 +18,52 @@ const REAL_MSG_STUB_TYPES = new Set([
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([
     Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD
 ]);
+
+/** Helper function to normalize JID */
+const normalizeToJid = (jid) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    if ((0, WABinary_1.isLid)(jid)) {
+        const decoded = (0, WABinary_1.lidToJid)(jid);
+        return decoded || jid;
+    }
+    return jid;
+};
+
 /** Cleans a received message to further processing */
 const cleanMessage = (message, meId) => {
     // ensure remoteJid and participant doesn't have device or agent in it
     // normalize JIDs but catch errors to avoid throwing on invalid LIDs/JIDs
     try {
-        message.key.remoteJid = (0, WABinary_1.jidNormalizedUser)(message.key.remoteJid);
+        const r0 = message.key.remoteJid;
+        if (r0) {
+            const rd = (0, WABinary_1.jidDecode)(r0);
+            if (rd === null || rd === void 0 ? void 0 : rd.user) {
+                message.key.remoteLid = message.key.remoteLid || ((0, WABinary_1.isLid)(r0) ? r0 : (0, WABinary_1.jidEncode)(rd.user, 'lid'));
+            }
+        }
+        message.key.remoteJid = normalizeToJid(message.key.remoteJid);
     }
     catch (_e) {
         // if normalization fails, retain original remoteJid
     }
     if (message.key.participant) {
         try {
-            message.key.participant = (0, WABinary_1.jidNormalizedUser)(message.key.participant);
+            const p0 = message.key.participant;
+            if (p0) {
+                const pd = (0, WABinary_1.jidDecode)(p0);
+                if (pd === null || pd === void 0 ? void 0 : pd.user) {
+                    message.key.participantLid = message.key.participantLid || ((0, WABinary_1.isLid)(p0) ? p0 : (0, WABinary_1.jidEncode)(pd.user, 'lid'));
+                }
+            }
+            message.key.participant = normalizeToJid(message.key.participant);
         }
         catch (_e) {
             // ignore if can't normalize participant
         }
     }
+    message.key.remoteJidNormalized = message.key.remoteJid;
     const content = (0, messages_1.normalizeMessageContent)(message.message);
     // if the message has a reaction, ensure fromMe & remoteJid are from our perspective
     if (content === null || content === void 0 ? void 0 : content.reactionMessage) {
@@ -211,9 +239,10 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 const response = protocolMsg.peerDataOperationRequestResponseMessage;
                 if (response) {
                     placeholderResendCache === null || placeholderResendCache === void 0 ? void 0 : placeholderResendCache.del(response.stanzaId);
-                    // TODO: IMPLEMENT HISTORY SYNC ETC (sticker uploads etc.).
+                    // Handle peer data operation results including sticker uploads, media uploads, link previews, and history sync
                     const { peerDataOperationResult } = response;
                     for (const result of peerDataOperationResult) {
+                        // Handle placeholder message resend responses
                         const { placeholderMessageResendResponse: retryResponse } = result;
                         if (retryResponse) {
                             const webMessageInfo = WAProto_1.proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes);
@@ -226,6 +255,51 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                                 });
                             }, 500);
                         }
+                        
+                        // Handle sticker message results
+                        if (result.stickerMessage) {
+                            ev.emit('sticker.upload-result', {
+                                stickerMessage: result.stickerMessage,
+                                requestId: response.stanzaId
+                            });
+                        }
+                        
+                        // Handle media upload results
+                        if (result.mediaUploadResult !== undefined) {
+                            ev.emit('media.upload-result', {
+                                result: result.mediaUploadResult,
+                                requestId: response.stanzaId
+                            });
+                        }
+                        
+                        // Handle link preview responses
+                        if (result.linkPreviewResponse) {
+                            ev.emit('link-preview.response', {
+                                response: result.linkPreviewResponse,
+                                requestId: response.stanzaId
+                            });
+                        }
+                        
+                        // Handle history sync chunk retry responses
+                        if (result.historySyncChunkRetryResponse) {
+                            const historySyncResponse = result.historySyncChunkRetryResponse;
+                            ev.emit('history-sync.chunk-retry', {
+                                syncType: historySyncResponse.syncType,
+                                chunkOrder: historySyncResponse.chunkOrder,
+                                requestId: historySyncResponse.requestId,
+                                responseCode: historySyncResponse.responseCode,
+                                canRecover: historySyncResponse.canRecover,
+                                stanzaId: response.stanzaId
+                            });
+                        }
+                        
+                        // Handle full history sync on-demand responses
+                        if (result.fullHistorySyncOnDemandRequestResponse) {
+                            ev.emit('history-sync.on-demand-response', {
+                                response: result.fullHistorySyncOnDemandRequestResponse,
+                                requestId: response.stanzaId
+                            });
+                        }
                     }
                 }
             case WAProto_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT:
@@ -262,25 +336,39 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         const jid = (_f = message.key) === null || _f === void 0 ? void 0 : _f.remoteJid;
         //let actor = whatsappID (message.participant)
         let participants;
-        const emitParticipantsUpdate = (action) => (ev.emit('group-participants.update', { id: jid, author: message.participant, participants, action }));
+        const author = normalizeToJid(message.participant);
+        const emitParticipantsUpdate = (action) => (ev.emit('group-participants.update', { id: jid, author, participants, action }));
         const emitGroupUpdate = (update) => {
             var _a;
-            ev.emit('groups.update', [{ id: jid, ...update, author: (_a = message.participant) !== null && _a !== void 0 ? _a : undefined }]);
+            ev.emit('groups.update', [{ id: jid, ...update, author: (_a = author) !== null && _a !== void 0 ? _a : undefined }]);
         };
         const emitGroupRequestJoin = (participant, action, method) => {
-            ev.emit('group.join-request', { id: jid, author: message.participant, participant, action, method: method });
+            ev.emit('group.join-request', { id: jid, author, participant: normalizeToJid(participant), action, method: method });
         };
         const participantsIncludesMe = () => participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid));
         switch (message.messageStubType) {
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:
-                participants = message.messageStubParameters || [];
+                participants = (message.messageStubParameters || []).map(normalizeToJid);
+                participants = participants.map(p => {
+                    if (typeof p === 'string') {
+                        const cleanedJid = (0, WABinary_1.validateAndCleanJid)(p);
+                        return cleanedJid;
+                    }
+                    return p;
+                });
                 emitParticipantsUpdate('modify');
                 break;
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_LEAVE:
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
-                participants = message.messageStubParameters || [];
+                participants = (message.messageStubParameters || []).map(normalizeToJid);
+                participants = participants.map(p => {
+                    if (typeof p === 'string') {
+                        const cleanedJid = (0, WABinary_1.validateAndCleanJid)(p);
+                        return cleanedJid;
+                    }
+                    return p;
+                });
                 emitParticipantsUpdate('remove');
-                // mark the chat read only if you left the group
                 if (participantsIncludesMe()) {
                     chat.readOnly = true;
                 }
@@ -288,18 +376,42 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD:
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_INVITE:
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD_REQUEST_JOIN:
-                participants = message.messageStubParameters || [];
+                participants = (message.messageStubParameters || []).map(normalizeToJid);
+                // Additional safety check: ensure all participants are proper JIDs
+                participants = participants.map(p => {
+                    if (typeof p === 'string') {
+                        const cleanedJid = (0, WABinary_1.validateAndCleanJid)(p);
+                        return cleanedJid;
+                    }
+                    return p;
+                });
                 if (participantsIncludesMe()) {
                     chat.readOnly = false;
                 }
                 emitParticipantsUpdate('add');
                 break;
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_DEMOTE:
-                participants = message.messageStubParameters || [];
+                participants = (message.messageStubParameters || []).map(normalizeToJid);
+                // Additional safety check: ensure all participants are proper JIDs
+                participants = participants.map(p => {
+                    if (typeof p === 'string') {
+                        const cleanedJid = (0, WABinary_1.validateAndCleanJid)(p);
+                        return cleanedJid;
+                    }
+                    return p;
+                });
                 emitParticipantsUpdate('demote');
                 break;
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_PROMOTE:
-                participants = message.messageStubParameters || [];
+                participants = (message.messageStubParameters || []).map(normalizeToJid);
+                // Additional safety check: ensure all participants are proper JIDs
+                participants = participants.map(p => {
+                    if (typeof p === 'string') {
+                        const cleanedJid = (0, WABinary_1.validateAndCleanJid)(p);
+                        return cleanedJid;
+                    }
+                    return p;
+                });
                 emitParticipantsUpdate('promote');
                 break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_ANNOUNCE:

package/lib/Utils/rate-limiter.js

@@ -1,13 +1,18 @@
 "use strict";
 
-/**
- * RateLimiter class for controlling message sending frequency
- * to prevent ban detection by simulating human-like behavior
- */
 class RateLimiter {
-    constructor(limitPerSecond = 1) {
+    /**
+     * @param {object} [options] - Configuration options
+     * @param {number} [options.limitPerSecond=1] - Number of tasks to process per second
+     * @param {number} [options.maxRandomDelayMs=500] - Maximum random delay to add after each task in milliseconds
+     */
+    constructor(options = {}) {
+        const { limitPerSecond = 1, maxRandomDelayMs = 500 } = options;
+
         this.limitPerSecond = limitPerSecond;
-        this.interval = 1000 / limitPerSecond; // milliseconds between messages
+        this.interval = 1000 / this.limitPerSecond;
+        this.maxRandomDelayMs = maxRandomDelayMs;
+
         this.queue = [];
         this.processing = false;
         this.lastSendTime = 0;
@@ -26,10 +31,6 @@ class RateLimiter {
             }
         });
     }
-
-    /**
-     * Process the queue with rate limiting
-     */
     async process() {
         if (this.processing || this.queue.length === 0) {
             return;
@@ -41,8 +42,6 @@ class RateLimiter {
             const { task, resolve, reject } = this.queue.shift();
             const now = Date.now();
             const timeSinceLastSend = now - this.lastSendTime;
-
-            // Wait if we need to respect the rate limit
             if (timeSinceLastSend < this.interval) {
                 const waitTime = this.interval - timeSinceLastSend;
                 await new Promise(r => setTimeout(r, waitTime));
@@ -55,10 +54,10 @@ class RateLimiter {
             } catch (error) {
                 reject(error);
             }
-
-            // Add small random delay to simulate human behavior (0-500ms)
-            const randomDelay = Math.random() * 500;
-            await new Promise(r => setTimeout(r, randomDelay));
+            if (this.maxRandomDelayMs > 0) {
+                const randomDelay = Math.random() * this.maxRandomDelayMs;
+                await new Promise(r => setTimeout(r, randomDelay));
+            }
         }
 
         this.processing = false;
@@ -80,10 +79,6 @@ class RateLimiter {
     getQueueLength() {
         return this.queue.length;
     }
-
-    /**
-     * Clear all pending tasks
-     */
     clear() {
         this.queue.forEach(({ reject }) => {
             reject(new Error('Rate limiter cleared'));

package/lib/WABinary/generic-utils.js

@@ -54,7 +54,11 @@ exports.getBinaryNodeChildUInt = getBinaryNodeChildUInt;
 const assertNodeErrorFree = (node) => {
     const errNode = (0, exports.getBinaryNodeChild)(node, 'error');
     if (errNode) {
-        throw new boom_1.Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code });
+        const code = +errNode.attrs.code;
+        throw new boom_1.Boom(errNode.attrs.text || 'Unknown error', {
+            data: code,
+            statusCode: code || undefined
+        });
     }
 };
 exports.assertNodeErrorFree = assertNodeErrorFree;

package/lib/WABinary/jid-utils.d.ts

@@ -34,4 +34,5 @@ export declare const isJidStatusBroadcast: (jid: string) => jid is "status@broad
 export declare const isJidBot: (jid: string | undefined) => boolean | "" | undefined;
 export declare const jidNormalizedUser: (jid: string | undefined) => string;
 export declare const lidToJid: (jid: string) => string;
+export declare const resolveJid: (jid: string | undefined) => string | undefined;
 export declare const getBotJid: (jid: string) => string;