@realvare/based 2.6.1 → 2.6.22

package/lib/Socket/messages-recv.js

@@ -11,6 +11,7 @@ const WAProto_1 = require("../../WAProto");
 const Defaults_1 = require("../Defaults");
 const Types_1 = require("../Types");
 const Utils_1 = require("../Utils");
+const performance_config_1 = require("../Utils/performance-config");
 const make_mutex_1 = require("../Utils/make-mutex");
 const WABinary_1 = require("../WABinary");
 const groups_1 = require("./groups");
@@ -1048,25 +1049,48 @@ const makeMessagesRecvSocket = (config) => {
             upsertMessage(protoMsg, call.offline ? 'append' : 'notify');
         }
     });
-    ev.on('connection.update', ({ isOnline }) => {
-        if (typeof isOnline !== 'undefined') {
-            sendActiveReceipts = isOnline;
+    ev.on('connection.update', (update) => {
+        const { connection, lastDisconnect } = update;
+
+        if (connection === 'close') {
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            const shouldReconnect = statusCode !== Types_1.DisconnectReason.loggedOut;
+
+            if (shouldReconnect) {
+                logger.info('Connection closed, will handle reconnection automatically');
+            } else {
+                logger.warn('Logged out, manual re-authentication required');
+            }
+        } else if (connection === 'open') {
+            sendActiveReceipts = true;
+        }
+
+        // Update sendActiveReceipts based on connection status
+        if (typeof update.isOnline !== 'undefined') {
+            sendActiveReceipts = update.isOnline;
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
     });
 
-    // Retry logic for stuck pending messages
+    // Enhanced retry logic for stuck pending messages with anti-ban delays
     ev.on('messages.update', (updates) => {
+        const config = getPerformanceConfig();
         updates.forEach(update => {
             if (update.update.status === WAProto_1.proto.WebMessageInfo.Status.PENDING &&
                 Date.now() - (update.update.timestamp || 0) > 30000) { // 30 seconds
-                logger.debug({ key: update.key }, 'retrying stuck pending message');
-                // Retry by re-sending the message
-                getMessage(update.key).then(msg => {
-                    if (msg) {
-                        relayMessage(update.key.remoteJid, msg, { messageId: update.key.id });
+                logger.debug({ key: update.key }, 'retrying stuck pending message with anti-ban delay');
+
+                // Apply anti-ban delay before retry
+                setTimeout(async () => {
+                    try {
+                        const msg = await getMessage(update.key);
+                        if (msg) {
+                            await relayMessage(update.key.remoteJid, msg, { messageId: update.key.id });
+                        }
+                    } catch (err) {
+                        logger.error({ err, key: update.key }, 'failed to retry stuck message');
                     }
-                }).catch(err => logger.error({ err, key: update.key }, 'failed to retry stuck message'));
+                }, config.security?.messageDelay?.min || 1000);
             }
         });
     });

package/lib/Socket/messages-send.js

@@ -16,10 +16,12 @@ const WABinary_1 = require("../WABinary");
 const WAUSync_1 = require("../WAUSync");
 const newsletter_1 = require("./newsletter");
 const rate_limiter_1 = __importDefault(require("../Utils/rate-limiter"));
+const { generateThumbnail } = require("../Utils/thumbnail");
 const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: axiosOptions, patchMessageBeforeSending, cachedGroupMetadata, } = config;
     const sock = (0, newsletter_1.makeNewsletterSocket)(config);
     const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, } = sock;
+
     const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
         useClones: false
@@ -275,6 +277,26 @@ const makeMessagesSocket = (config) => {
         const isStatus = jid === statusJid;
         const isLid = server === 'lid';
         msgId = msgId || (0, Utils_1.generateMessageIDV2)((_a = sock.user) === null || _a === void 0 ? void 0 : _a.id);
+        if(message.contextInfo?.externalAdReply?.thumbnailUrl) {
+            try {
+                const { externalAdReply } = message.contextInfo;
+                const thumbnail = await generateThumbnail(externalAdReply.thumbnailUrl);
+                message.contextInfo.externalAdReply = {
+                    ...externalAdReply,
+                    thumbnail,
+                    renderLargerThumbnail: false,
+                };
+                delete message.contextInfo.externalAdReply.thumbnailUrl;
+                logger?.debug('Successfully generated thumbnail for external ad reply');
+            } catch(err) {
+                logger?.warn({ trace: err.stack, msg: message.contextInfo.externalAdReply }, 'failed to generate thumbnail for external ad reply, keeping thumbnailUrl as fallback');
+                // Ensure renderLargerThumbnail is set to false even on failure
+                if (message.contextInfo.externalAdReply.renderLargerThumbnail === undefined) {
+                    message.contextInfo.externalAdReply.renderLargerThumbnail = false;
+                }
+            }
+        }
+
         useUserDevicesCache = useUserDevicesCache !== false;
         useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
         const participants = [];
@@ -766,9 +788,9 @@ const makeMessagesSocket = (config) => {
                             parentMessageKey: albumMsg.key
                         }
                     };
-                    await relayMessage(jid, mediaMsg.message, {
+                    await rateLimiter.add(() => relayMessage(jid, mediaMsg.message, {
                         messageId: mediaMsg.key.id
-                    });
+                    }));
                     await new Promise(resolve => setTimeout(resolve, 800));
                 }
             }
@@ -878,7 +900,7 @@ const makeMessagesSocket = (config) => {
                         parentMessageKey: packMsg.key
                     }
                 };
-                await relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id });
+                await rateLimiter.add(() => relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id }));
                 lastMsg = stickerMsg;
                 // Add delay between stickers to avoid rate limiting
                 await new Promise(resolve => setTimeout(resolve, 800));
@@ -1128,9 +1150,9 @@ const makeMessagesSocket = (config) => {
                         expectedVideoCount: album.filter(item => 'video' in item).length
                     }
                 }, { userJid, ...options });
-                await relayMessage(jid, albumMsg.message, {
+                await rateLimiter.add(() => relayMessage(jid, albumMsg.message, {
                     messageId: albumMsg.key.id
-                });
+                }));
                 for (const i in album) {
                     const media = album[i];
                     if ('image' in media) {
@@ -1291,18 +1313,17 @@ const makeMessagesSocket = (config) => {
                         messageId: (0, Utils_1.generateMessageIDV2)((_c = sock.user) === null || _c === void 0 ? void 0 : _c.id),
                         ...options,
                     });
-                    // Associate sticker with the pack message
-                    stickerMsg.message.messageContextInfo = {
-                        messageSecret: (0, crypto_1.randomBytes)(32),
-                        messageAssociation: {
-                            associationType: 1,
-                            parentMessageKey: packMsg.key
-                        }
-                    };
-                    await relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id });
-                    lastMsg = stickerMsg;
-                    // Add delay between stickers to avoid rate limiting
-                    await new Promise(resolve => setTimeout(resolve, 800));
+                // Associate sticker with the pack message
+                stickerMsg.message.messageContextInfo = {
+                    messageSecret: (0, crypto_1.randomBytes)(32),
+                    messageAssociation: {
+                        associationType: 1,
+                        parentMessageKey: packMsg.key
+                    }
+                };
+                await rateLimiter.add(() => relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id }));
+                lastMsg = stickerMsg;
+                await new Promise(resolve => setTimeout(resolve, 800));
                 }
                 return lastMsg;
             }

package/lib/Socket/socket.js

@@ -698,8 +698,7 @@ const makeSocket = (config) => {
                 values,
                 selectableCount: selectableCount || 1,
             };
-            // @ts-ignore
-            return ws.sendMessage(jid, { poll: pollCreation });
+            return sock.sendMessage(jid, { poll: pollCreation });
         },
         // lid related functions
         assertLid: (jid) => {

package/lib/Types/Socket.d.ts

@@ -29,7 +29,7 @@ export type SocketConfig = {
     connectTimeoutMs: number;
     /** Default timeout for queries, undefined for no timeout */
     defaultQueryTimeoutMs: number | undefined;
-    /** ping-pong interval for WS connection */
+    /** ping- inpongterval for WS connection */
     keepAliveIntervalMs: number;
     /** should baileys use the mobile api instead of the multi device api
     * @deprecated This feature has been removed

package/lib/Utils/cache-manager.js

@@ -7,20 +7,24 @@ class CacheManager {
         const config = getPerformanceConfig();
         this.caches = {};
         this.memoryCheckInterval = null;
-        
+        this.msgStore = null;
+
         // Inizializza le cache con TTL
         Object.entries(config.cache).forEach(([name, options]) => {
             this.caches[name] = new NodeCache({
-                stdTTL: options.ttl / 1000, // Converti da ms a secondi
+                stdTTL: options.ttl / 1000,
                 checkperiod: options.cleanupInterval / 1000,
                 maxKeys: options.maxSize
             });
         });
-        
+
         if (config.performance.enableMetrics) {
             this.startMemoryMonitoring(config.performance.memoryThreshold);
         }
     }
+    setMessageStore(msgStore) {
+        this.msgStore = msgStore;
+    }
     
     startMemoryMonitoring(threshold) {
         this.memoryCheckInterval = setInterval(() => {

package/lib/Utils/link-preview.js

@@ -36,12 +36,27 @@ 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 = 192;
+const THUMBNAIL_WIDTH_PX = 1200;
 /** Fetches an image and generates a thumbnail for it */
-const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
-    const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts);
-    const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth);
-    return result;
+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
@@ -86,6 +101,7 @@ const getUrlInfo = async (text, opts = {
         });
         if (info && 'title' in info && info.title) {
             const [image] = info.images;
+            opts.logger?.debug({ url: previewLink, title: info.title, imageCount: info.images.length }, 'Fetched link preview info');
             const urlInfo = {
                 'canonical-url': info.url,
                 'matched-text': text,
@@ -107,7 +123,7 @@ const getUrlInfo = async (text, opts = {
             else {
                 try {
                     urlInfo.jpegThumbnail = image
-                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
+                        ? (await getCompressedJpegThumbnail(image, { ...opts, logger: opts.logger })).buffer
                         : undefined;
                 }
                 catch (error) {

package/lib/Utils/logger.js

@@ -4,4 +4,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const pino_1 = __importDefault(require("pino"));
-exports.default = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+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/messages-media.js

@@ -479,21 +479,8 @@ async function generateThumbnail(file, mediaType, options) {
     };
 }
 const getHttpStream = async (url, options = {}) => {
-    const { retryRequestDelayMs, maxMsgRetryCount } = options;
-    let retries = 0;
-    while (retries < maxMsgRetryCount) {
-        try {
-            const fetched = await axios_1.default.get(url.toString(), { ...options, responseType: 'stream' });
-            return fetched.data;
-        }
-        catch (error) {
-            retries++;
-            if (retries >= maxMsgRetryCount) {
-                throw error;
-            }
-            await (0, generics_1.delay)(retryRequestDelayMs || 1000);
-        }
-    }
+    const fetched = await axios_1.default.get(url.toString(), { ...options, responseType: 'stream' });
+    return fetched.data;
 };
 exports.getHttpStream = getHttpStream;
 const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {

package/lib/Utils/messages.js

@@ -245,14 +245,14 @@ const generateWAMessageContent = async (message, options) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     var _p, _q;
 
-    // iOS-specific externalAdReply handling
+    // Cross-platform externalAdReply thumbnail handling
     if (message.contextInfo?.externalAdReply) {
         const externalAdReply = message.contextInfo.externalAdReply;
 
-        // If thumbnailUrl is provided but no thumbnail binary data, try to fetch and convert for iOS
+        // If thumbnailUrl is provided but no thumbnail binary data, try to fetch and convert for all platforms
         if (externalAdReply.thumbnailUrl && !externalAdReply.thumbnail) {
             try {
-                // Attempt to download the thumbnail image for iOS compatibility
+                // Attempt to download the thumbnail image for cross-platform compatibility
                 const axiosResponse = await axios_1.default.get(externalAdReply.thumbnailUrl, {
                     responseType: 'arraybuffer',
                     timeout: 5000,
@@ -265,13 +265,20 @@ const generateWAMessageContent = async (message, options) => {
                     externalAdReply.thumbnail = Buffer.from(axiosResponse.data);
                     // Clear thumbnailUrl since we now have binary data
                     delete externalAdReply.thumbnailUrl;
+                    options.logger?.debug('Successfully downloaded externalAdReply thumbnail for cross-platform compatibility');
                 }
             } catch (error) {
-                // If thumbnail download fails, keep thumbnailUrl as is
-                options.logger?.warn('Failed to download externalAdReply thumbnail for iOS:', error.message);
+                // If thumbnail download fails, keep thumbnailUrl as fallback
+                options.logger?.warn('Failed to download externalAdReply thumbnail for cross-platform compatibility:', error.message);
             }
         }
 
+        // Ensure renderLargerThumbnail is set for better display across platforms
+        if (externalAdReply.renderLargerThumbnail === undefined) {
+            externalAdReply.renderLargerThumbnail = false;
+            options.logger?.debug('Set renderLargerThumbnail=false for improved cross-platform display');
+        }
+
         // Update the contextInfo with modified externalAdReply
         message.contextInfo.externalAdReply = externalAdReply;
     }
@@ -557,7 +564,7 @@ const generateWAMessageContent = async (message, options) => {
                     thumbnail: extAdReply.thumbnail,
                     sourceUrl: extAdReply.sourceUrl,
                     showAdAttribution: extAdReply.showAdAttribution || false,
-                    renderLargerThumbnail: extAdReply.renderLargerThumbnail || false
+                    renderLargerThumbnail: extAdReply.renderLargerThumbnail !== false
                 }
             }
         };
@@ -1187,187 +1194,50 @@ const assertMediaContent = (content) => {
     return mediaContent;
 };
 exports.assertMediaContent = assertMediaContent;
-
-// Cache per ottimizzare le conversioni LID/JID
-const lidCache = new Map();
-const jidCache = new Map();
-const CACHE_TTL = 5 * 60 * 1000; // 5 minuti
-const MAX_CACHE_SIZE = 10000; // Massimo 10k entries
-
-// Funzione per pulire cache scadute
-const cleanExpiredCache = (cache) => {
-    const now = Date.now();
-    for (const [key, value] of cache.entries()) {
-        if (now - value.timestamp > CACHE_TTL) {
-            cache.delete(key);
-        }
-    }
-    
-    // Se la cache è troppo grande, rimuovi le entry più vecchie
-    if (cache.size > MAX_CACHE_SIZE) {
-        const entries = Array.from(cache.entries());
-        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-        const toRemove = entries.slice(0, Math.floor(MAX_CACHE_SIZE * 0.2));
-        toRemove.forEach(([key]) => cache.delete(key));
-    }
+const getNormalizedJid = (jid) => {
+    if (!jid) return jid;
+    return (0, WABinary_1.jidNormalizedUser)(jid);
 };
+exports.getNormalizedJid = getNormalizedJid;
 
-// Pulisci cache ogni 2 minuti
-setInterval(() => {
-    cleanExpiredCache(lidCache);
-    cleanExpiredCache(jidCache);
-}, 2 * 60 * 1000);
+const isLidFormat = (jid) => {
+    return (0, WABinary_1.isLidUser)(jid);
+};
+exports.isLidFormat = isLidFormat;
 
+// Legacy compatibility functions - deprecated, use native APIs
 const toJid = (id) => {
-    try {
-        if (!id || typeof id !== 'string') {
-            return '';
-        }
-        
-        // Controlla cache
-        if (jidCache.has(id)) {
-            const cached = jidCache.get(id);
-            if (Date.now() - cached.timestamp < CACHE_TTL) {
-                return cached.result;
-            } else {
-                jidCache.delete(id);
-            }
-        }
-        
-        let result = '';
-        
-        if (id.endsWith('@lid')) {
-            result = id.replace('@lid', '@s.whatsapp.net');
-        } else if (id.includes('@')) {
-            result = id;
-        } else {
-            result = `${id}@s.whatsapp.net`;
-        }
-        
-        // Salva in cache
-        jidCache.set(id, {
-            result,
-            timestamp: Date.now()
-        });
-        
-        return result;
-    } catch (error) {
-        console.error('Error in toJid:', error.message, 'Input:', id);
-        return id || '';
-    }
+    console.warn('toJid is deprecated. Use getNormalizedJid instead.');
+    return getNormalizedJid(id);
 };
 exports.toJid = toJid;
 
 const getSenderLid = (message) => {
-    try {
-        if (!message?.key) {
-            throw new Error('Invalid message: missing key property');
-        }
-        
-        const sender = message.key.participant || message.key.remoteJid;
-        if (!sender) {
-            throw new Error('Invalid message: missing sender information');
-        }
-        
-        // Controlla cache
-        if (lidCache.has(sender)) {
-            const cached = lidCache.get(sender);
-            if (Date.now() - cached.timestamp < CACHE_TTL) {
-                return cached.result;
-            } else {
-                lidCache.delete(sender);
-            }
-        }
-        
-        const decoded = (0, WABinary_1.jidDecode)(sender);
-        if (!decoded?.user) {
-            throw new Error(`Invalid JID format: ${sender}`);
-        }
-        
-        const user = decoded.user;
-        const lid = (0, WABinary_1.jidEncode)(user, 'lid');
-        
-        const result = { 
-            jid: sender, 
-            lid,
-            isValid: true,
-            user,
-            timestamp: Date.now()
-        };
-        
-        // Log solo in debug mode
-        if (process.env.DEBUG_LID === 'true') {
-            console.log('sender lid:', lid, 'user:', user);
-        }
-        
-        // Salva in cache
-        lidCache.set(sender, {
-            result,
-            timestamp: Date.now()
-        });
-        
-        return result;
-        
-    } catch (error) {
-        console.error('Error in getSenderLid:', error.message, 'Message:', message?.key);
-        
-        // Ritorna un oggetto di fallback valido
-        return {
-            jid: message?.key?.remoteJid || 'unknown',
-            lid: 'unknown@lid',
-            isValid: false,
-            user: 'unknown',
-            error: error.message,
-            timestamp: Date.now()
-        };
-    }
-};
-exports.getSenderLid = getSenderLid;
+    console.warn('getSenderLid is deprecated. Use getNormalizedJid and isLidFormat instead.');
+    const sender = message?.key?.participant || message?.key?.remoteJid;
+    if (!sender) return null;
 
-// Utility functions per performance e debugging
-const getCacheStats = () => {
+    const normalized = getNormalizedJid(sender);
     return {
-        lidCache: {
-            size: lidCache.size,
-            maxSize: MAX_CACHE_SIZE,
-            ttl: CACHE_TTL
-        },
-        jidCache: {
-            size: jidCache.size,
-            maxSize: MAX_CACHE_SIZE,
-            ttl: CACHE_TTL
-        }
+        jid: sender,
+        lid: normalized,
+        isValid: true,
+        user: (0, WABinary_1.jidDecode)(normalized)?.user || 'unknown'
     };
 };
-exports.getCacheStats = getCacheStats;
-
-const clearCache = () => {
-    lidCache.clear();
-    jidCache.clear();
-    console.log(chalk.bold.magenta('- 🎐 | Cache cancellata correttamente'));
-};
-exports.clearCache = clearCache;
+exports.getSenderLid = getSenderLid;
 
 const validateJid = (jid) => {
+    console.warn('validateJid is deprecated. Use native Baileys validation.');
     if (!jid || typeof jid !== 'string') {
         return { isValid: false, error: 'Invalid JID: must be a non-empty string' };
     }
-    
-    const parts = jid.split('@');
-    if (parts.length !== 2) {
-        return { isValid: false, error: 'Invalid JID format: must contain exactly one @' };
-    }
-    
-    const [user, server] = parts;
-    if (!user || !server) {
-        return { isValid: false, error: 'Invalid JID: user and server parts cannot be empty' };
-    }
-    
-    const validServers = ['s.whatsapp.net', 'g.us', 'broadcast', 'newsletter', 'lid', 'c.us'];
-    if (!validServers.includes(server)) {
-        return { isValid: false, error: `Invalid server: ${server}. Must be one of: ${validServers.join(', ')}` };
+
+    try {
+        const decoded = (0, WABinary_1.jidDecode)(jid);
+        return { isValid: !!decoded };
+    } catch {
+        return { isValid: false, error: 'Invalid JID format' };
     }
-    
-    return { isValid: true };
 };
 exports.validateJid = validateJid;