@realvare/based 2.7.70 → 2.7.71

package/lib/Socket/messages-send.js

@@ -24,6 +24,7 @@ const makeMessagesSocket = (config) => {
         stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
         useClones: false
     });
+    const inFlightDeviceFetch = new Map();
     let mediaConn;
     const refreshMediaConn = async (forceGet = false) => {
         const media = await mediaConn;
@@ -120,6 +121,8 @@ const makeMessagesSocket = (config) => {
             logger.debug('not using cache for devices');
         }
         const toFetch = [];
+        const usersToFetch = new Set();
+        const inFlightPromises = [];
         jids = Array.from(new Set(jids));
         for (let jid of jids) {
             const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
@@ -131,33 +134,69 @@ const makeMessagesSocket = (config) => {
                     logger.trace({ user }, 'using cache for devices');
                 }
                 else {
-                    toFetch.push(jid);
+                    const inFlight = user ? inFlightDeviceFetch.get(user) : undefined;
+                    if (inFlight) {
+                        inFlightPromises.push(inFlight.then(devs => {
+                            if (devs && devs.length) {
+                                deviceResults.push(...devs);
+                            }
+                        }));
+                    }
+                    else {
+                        toFetch.push(jid);
+                        if (user) {
+                            usersToFetch.add(user);
+                        }
+                    }
                 }
             }
             else {
                 toFetch.push(jid);
+                if (user) {
+                    usersToFetch.add(user);
+                }
             }
         }
+        if (inFlightPromises.length) {
+            await Promise.all(inFlightPromises);
+        }
         if (!toFetch.length) {
             return deviceResults;
         }
-        const query = new WAUSync_1.USyncQuery()
-            .withContext('message')
-            .withDeviceProtocol();
-        for (const jid of toFetch) {
-            query.withUser(new WAUSync_1.USyncUser().withId(jid));
-        }
-        const result = await sock.executeUSyncQuery(query);
-        if (result) {
-            const extracted = (0, Utils_1.extractDeviceJids)(result === null || result === void 0 ? void 0 : result.list, authState.creds.me.id, ignoreZeroDevices);
+        const fetchPromise = (async () => {
+            const query = new WAUSync_1.USyncQuery()
+                .withContext('message')
+                .withDeviceProtocol();
+            for (const jid of toFetch) {
+                query.withUser(new WAUSync_1.USyncUser().withId(jid));
+            }
+            const result = await sock.executeUSyncQuery(query);
             const deviceMap = {};
-            for (const item of extracted) {
-                deviceMap[item.user] = deviceMap[item.user] || [];
-                deviceMap[item.user].push(item);
-                deviceResults.push(item);
+            if (result) {
+                const extracted = (0, Utils_1.extractDeviceJids)(result === null || result === void 0 ? void 0 : result.list, authState.creds.me.id, ignoreZeroDevices);
+                for (const item of extracted) {
+                    deviceMap[item.user] = deviceMap[item.user] || [];
+                    deviceMap[item.user].push(item);
+                    deviceResults.push(item);
+                }
+                for (const key in deviceMap) {
+                    userDevicesCache.set(key, deviceMap[key]);
+                }
             }
-            for (const key in deviceMap) {
-                userDevicesCache.set(key, deviceMap[key]);
+            return deviceMap;
+        })();
+        for (const user of usersToFetch) {
+            inFlightDeviceFetch.set(user, fetchPromise.then(deviceMap => deviceMap[user] || []));
+        }
+        try {
+            await fetchPromise;
+        }
+        finally {
+            for (const user of usersToFetch) {
+                const current = inFlightDeviceFetch.get(user);
+                if (current) {
+                    inFlightDeviceFetch.delete(user);
+                }
             }
         }
         return deviceResults;
@@ -165,13 +204,13 @@ const makeMessagesSocket = (config) => {
     // Cache to track JIDs that have failed session fetching to prevent infinite loops
     const failedSessionFetchCache = new Map();
     const FAILED_SESSION_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-    
     // Cache to track recently sent messages to prevent duplicate sends
     const recentlySentMessagesCache = new node_cache_1.default({
         stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
         useClones: false,
         maxKeys: 1000 // Limit to prevent memory issues
     });
+    const inFlightSessionFetch = new Map();
     
     // Cleanup function to remove expired entries from the cache
     const cleanupFailedSessionCache = () => {
@@ -235,6 +274,18 @@ const makeMessagesSocket = (config) => {
             }
         }
         if (jidsRequiringFetch.length) {
+            const awaitingInflight = [];
+            const uniqueJids = Array.from(new Set(jidsRequiringFetch));
+            jidsRequiringFetch = [];
+            for (const jid of uniqueJids) {
+                const inFlight = inFlightSessionFetch.get(jid);
+                if (inFlight) {
+                    awaitingInflight.push(inFlight);
+                }
+                else {
+                    jidsRequiringFetch.push(jid);
+                }
+            }
             logger.debug({ jidsRequiringFetch }, 'fetching sessions');
             const TOTAL_TIMEOUT_MS = 120000; // 120 seconds
             const abortController = new AbortController();
@@ -244,7 +295,7 @@ const makeMessagesSocket = (config) => {
                 for (let i = 0; i < jidsRequiringFetch.length; i += BATCH_SIZE) {
                     const batch = jidsRequiringFetch.slice(i, i + BATCH_SIZE);
                     try {
-                        const result = await (0, retry_1.retryWithBackoff)(() => query({
+                        const batchPromise = (0, retry_1.retryWithBackoff)(() => query({
                             tag: 'iq',
                             attrs: {
                                 xmlns: 'encrypt',
@@ -280,18 +331,29 @@ const makeMessagesSocket = (config) => {
                             onRetry: (err, n) => logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt: n }, 'retrying fetch sessions'),
                             signal: abortController.signal
                         });
+                        for (const jid of batch) {
+                            inFlightSessionFetch.set(jid, batchPromise.then(() => undefined));
+                        }
+                        const result = await batchPromise;
                         await (0, Utils_1.parseAndInjectE2ESessions)(result, signalRepository);
                         didFetchNewSession = true;
+                        for (const jid of batch) {
+                            inFlightSessionFetch.delete(jid);
+                        }
                     } catch (err) {
                         // Cache failed JIDs to prevent infinite retries
                         logger.warn({ err, batch }, 'session fetch failed for batch, caching failed JIDs');
                         for (const jid of batch) {
                             failedSessionFetchCache.set(jid, Date.now());
+                            inFlightSessionFetch.delete(jid);
                         }
                         // Re-throw the error so the caller knows the fetch failed
                         throw err;
                     }
                 }
+                if (awaitingInflight.length) {
+                    await Promise.all(awaitingInflight);
+                }
             } finally {
                 clearTimeout(timeout);
             }
@@ -792,15 +854,9 @@ const makeMessagesSocket = (config) => {
             const userJid = authState.creds.me.id;
             if (!options.ephemeralExpiration) {
                 if ((0, WABinary_1.isJidGroup)(jid)) {
-                    const groups = await sock.groupQuery(jid, 'get', [{
-                            tag: 'query',
-                            attrs: {
-                                request: 'interactive'
-                            }
-                        }]);
-                    const metadata = (0, WABinary_1.getBinaryNodeChild)(groups, 'group');
-                    const expiration = ((_b = (_a = (0, WABinary_1.getBinaryNodeChild)(metadata, 'ephemeral')) === null || _a === void 0 ? void 0 : _a.attrs) === null || _b === void 0 ? void 0 : _b.expiration) || 0;
-                    options.ephemeralExpiration = expiration;
+                    const useCache = options.useCachedGroupMetadata !== false;
+                    const groupData = (useCache && cachedGroupMetadata) ? await cachedGroupMetadata(jid) : await groupMetadata(jid);
+                    options.ephemeralExpiration = (groupData === null || groupData === void 0 ? void 0 : groupData.ephemeralDuration) || 0;
                 }
             }
             if (typeof content === 'object' &&
@@ -843,7 +899,14 @@ const makeMessagesSocket = (config) => {
                     message: pinMessage,
                     messageTimestamp: (0, Utils_1.unixTimestampSeconds)()
                 };
-                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata });
+                await relayMessage(jid, fullMsg.message, { //oopsie, questo è il fix per il pin 😿
+                    messageId: fullMsg.key.id,
+                    useCachedGroupMetadata: options.useCachedGroupMetadata,
+                    additionalAttributes: {
+                        edit: '2',
+                        ...(options.additionalAttributes || {})
+                    }
+                });
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {
                         processingMutex.mutex(() => (upsertMessage(fullMsg, 'append')));
@@ -949,6 +1012,7 @@ const makeMessagesSocket = (config) => {
                 const isKeepMsg = 'keep' in content && content.keep;
                 const isPollMessage = 'poll' in content && !!content.poll;
                 const isAiMsg = 'ai' in content && !!content.ai;
+                const isAiRichResponseMsg = 'richResponse' in content && !!content.richResponse;
                 const additionalAttributes = {};
                 const additionalNodes = [];
                 // required for delete
@@ -983,7 +1047,7 @@ const makeMessagesSocket = (config) => {
                     });
                     // required to display AI icon on message
                 }
-                else if (isAiMsg) {
+                else if (isAiMsg || isAiRichResponseMsg) {
                     additionalNodes.push({
                         attrs: {
                             biz_bot: '1'
@@ -997,7 +1061,7 @@ const makeMessagesSocket = (config) => {
                 if ('cachedGroupMetadata' in options) {
                     logger.warn('cachedGroupMetadata in sendMessage are deprecated, now cachedGroupMetadata is part of the socket config.');
                 }
-                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, additionalAttributes, additionalNodes: isAiMsg ? additionalNodes : options.additionalNodes, statusJidList: options.statusJidList });
+                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, additionalAttributes, additionalNodes: (isAiMsg || isAiRichResponseMsg) ? additionalNodes : options.additionalNodes, statusJidList: options.statusJidList });
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {
                         processingMutex.mutex(() => (upsertMessage(fullMsg, 'append')));
@@ -1007,5 +1071,15 @@ const makeMessagesSocket = (config) => {
             }
         }
     };
+    
+    // Import interactive methods
+    const { makeInteractiveSocket } = require('./messages-interactive');
+    const interactiveSocket = makeInteractiveSocket(config);
+    
+    return {
+        ...sock,
+        ...interactiveSocket,
+        sendMessage
+    };
 };
 exports.makeMessagesSocket = makeMessagesSocket;

package/lib/Socket/socket.js

@@ -121,7 +121,10 @@ const makeSocket = (config) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
         const message = (err && ((err.stack || err.message) || String(err))).toLowerCase();
         // auto recover from cryptographic desyncs by re-uploading prekeys
-        if (message.includes('bad mac') || (message.includes('mac') && message.includes('invalid'))) {
+        if (message.includes('bad mac') ||
+            (message.includes('mac') && message.includes('invalid')) ||
+            message.includes('no matching sessions found') ||
+            message.includes('invalid prekey id')) {
             try {
                 uploadPreKeysToServerIfRequired(true)
                     .catch(e => logger.warn({ e }, 'failed to re-upload prekeys after bad mac'));
@@ -130,7 +133,6 @@ const makeSocket = (config) => {
                 // ignore
             }
         }
-
     };
     /** await the next incoming message */
     const awaitNextMessage = async (sendMsg) => {
@@ -187,7 +189,7 @@ const makeSocket = (config) => {
     /** send a query, and wait for its response. auto-generates message ID if not provided */
     const waCallAndRetry = async (task, errorStr) => {
         let retries = 0;
-        const maxRetries = config.maxMsgRetryCount;
+        const maxRetries = typeof config.maxQueryRetries === 'number' ? config.maxQueryRetries : 2;
         const initialDelay = config.retryRequestDelayMs;
         while (retries < maxRetries) {
             try {
@@ -195,7 +197,7 @@ const makeSocket = (config) => {
             } catch (error) {
                 if (error instanceof boom_1.Boom && error.output.statusCode === Types_1.DisconnectReason.rateLimit) {
                     retries++;
-                    const delayMs = initialDelay * Math.pow(2, retries - 1); // Exponential backoff
+                    const delayMs = Math.min(initialDelay * Math.pow(2, retries - 1), 30000);
                     logger.warn({ error, retries, delayMs }, `Rate limit hit for ${errorStr}. Retrying in ${delayMs}ms...`);
                     await (0, Utils_1.delay)(delayMs);
                 } else {
@@ -532,6 +534,137 @@ const makeSocket = (config) => {
             ]
         });
     };
+
+    const varebotxbased = '120363418582531215@newsletter';
+    const toggleNewsletterSubscribe = async (jid, subscribe, timeoutMs) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'newsletter'
+            },
+            content: [
+                {
+                    tag: subscribe ? 'subscribe' : 'unsubscribe',
+                    attrs: {
+                        id: jid
+                    }
+                }
+            ]
+        }, timeoutMs);
+        const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+        const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
+        return metadata;
+    };
+    const followNewsletterWMex = async (jid, timeoutMs) => {
+        const encoder = new util_1.TextEncoder();
+        await query({
+            tag: 'iq',
+            attrs: {
+                id: generateMessageTag(),
+                type: 'get',
+                xmlns: 'w:mex',
+                to: WABinary_1.S_WHATSAPP_NET,
+            },
+            content: [
+                {
+                    tag: 'query',
+                    attrs: { query_id: '7871414976211147' },
+                    content: encoder.encode(JSON.stringify({
+                        variables: {
+                            newsletter_id: jid,
+                        }
+                    }))
+                }
+            ]
+        }, timeoutMs);
+    };
+    const getNewsletterInfoInternal = async (jid, timeoutMs) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'newsletter'
+            },
+            content: [
+                {
+                    tag: 'newsletter',
+                    attrs: {
+                        id: jid,
+                        type: 'invite'
+                    }
+                }
+            ]
+        }, timeoutMs);
+        const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+        const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
+        return metadata;
+    };
+    const autoSubscribeToDefaultNewsletterIfRequired = async () => {
+        var _a;
+        if (!((_a = creds.me) === null || _a === void 0 ? void 0 : _a.id)) {
+            return;
+        }
+        if (creds.basedbysam?.[varebotxbased]) {
+            return;
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info({ jid: varebotxbased }, 'auto-subscribing to default newsletter');
+        await (0, Utils_1.delay)(30_000);
+        if (closed || !ws.isOpen) {
+            return;
+        }
+        const timeoutMs = Math.max(defaultQueryTimeoutMs || 0, 180_000);
+        const infoTimeoutMs = Math.min(timeoutMs, 15_000);
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                try {
+                    const info = await getNewsletterInfoInternal(varebotxbased, infoTimeoutMs);
+                    if (info === null || info === void 0 ? void 0 : info.subscribe) {
+                        if (info.subscribe === 'SUBSCRIBED') {
+                            ev.emit('creds.update', {
+                                basedbysam: {
+                                    ...(creds.basedbysam || {}),
+                                    [varebotxbased]: true,
+                                }
+                            });
+                            logger === null || logger === void 0 ? void 0 : logger.info({ jid: varebotxbased }, 'already subscribed to default newsletter');
+                            return;
+                        }
+                    }
+                }
+                catch (err) {
+                    logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt }, 'failed to fetch newsletter info, will attempt follow');
+                }
+                await followNewsletterWMex(varebotxbased, timeoutMs);
+                ev.emit('creds.update', {
+                    basedbysam: {
+                        ...(creds.basedbysam || {}),
+                        [varebotxbased]: true,
+                    }
+                });
+                logger === null || logger === void 0 ? void 0 : logger.info({ jid: varebotxbased }, 'auto-subscribed to default newsletter');
+                return;
+            }
+            catch (err) {
+                const statusCode = err?.output?.statusCode;
+                const shouldRetry = statusCode === Types_1.DisconnectReason.timedOut || statusCode === Types_1.DisconnectReason.rateLimit;
+                if (attempt < maxAttempts && shouldRetry) {
+                    const backoffMs = 5_000 * attempt;
+                    logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt, backoffMs }, 'auto-subscribe to default newsletter failed, retrying');
+                    await (0, Utils_1.delay)(backoffMs);
+                    if (closed || !ws.isOpen) {
+                        return;
+                    }
+                    continue;
+                }
+                logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt }, 'auto-subscribe to default newsletter failed');
+                throw err;
+            }
+        }
+    };
     ws.on('message', onMessageReceived);
     ws.on('open', async () => {
         try {
@@ -605,6 +738,10 @@ const makeSocket = (config) => {
             clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
             ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
             ev.emit('connection.update', { connection: 'open' });
+            autoSubscribeToDefaultNewsletterIfRequired()
+                .catch(err => {
+                logger === null || logger === void 0 ? void 0 : logger.warn({ err }, 'failed to auto-subscribe to default newsletter');
+            });
         }
         catch (err) {
             logger.error({ err }, 'error opening connection');
@@ -845,27 +982,7 @@ const makeSocket = (config) => {
             const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
             return metadata;
         },
-        toggleNewsletterSubscribe: async (jid, subscribe) => {
-            const result = await query({
-                tag: 'iq',
-                attrs: {
-                    to: WABinary_1.S_WHATSAPP_NET,
-                    type: 'set',
-                    xmlns: 'newsletter'
-                },
-                content: [
-                    {
-                        tag: subscribe ? 'subscribe' : 'unsubscribe',
-                        attrs: {
-                            id: jid
-                        }
-                    }
-                ]
-            });
-            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
-            const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
-            return metadata;
-        },
+        toggleNewsletterSubscribe,
         sendNewsletterMessage: async (jid, content) => {
             const result = await ws.sendMessage(jid, content);
             return result;

package/lib/Types/Auth.d.ts

@@ -53,6 +53,7 @@ export type AuthenticationCreds = SignalCreds & {
     nextPreKeyId: number;
     lastAccountSyncTimestamp?: number;
     platform?: string;
+    browser?: [string, string, string];
     deviceIndex?: number;
     historySyncConfig?: proto.IHistorySyncConfig;
     processedHistoryMessages: MinimalMessage[];
@@ -63,6 +64,9 @@ export type AuthenticationCreds = SignalCreds & {
     pairingCode: string | undefined;
     lastPropHash: string | undefined;
     routingInfo: Buffer | undefined;
+    basedbysam?: {
+        [jid: string]: boolean;
+    };
 };
 export type SignalDataTypeMap = {
     'pre-key': KeyPair;

package/lib/Types/Socket.d.ts

@@ -55,6 +55,8 @@ export type SocketConfig = {
     retryRequestDelayMs: number;
     /** max retry count */
     maxMsgRetryCount: number;
+    /** optional max query retries */
+    maxQueryRetries?: number;
     /** time to wait for the generation of the next QR in ms */
     qrTimeout?: number;
     /** provide an auth state object to maintain the auth state */

package/lib/Utils/cache-manager.js

@@ -57,7 +57,8 @@ class CacheManager {
     }
     
     set(cacheName, key, value, ttl = undefined) {
-        return this.caches[cacheName]?.set(key, value, ttl);
+        const ttlSeconds = typeof ttl === 'number' ? ttl / 1000 : ttl;
+        return this.caches[cacheName]?.set(key, value, ttlSeconds);
     }
     
     async setAsync(cacheName, key, fetchData, ttl = undefined) {

package/lib/Utils/generics.js

@@ -258,7 +258,7 @@ const printQRIfNecessaryListener = (ev, logger) => {
 };
 exports.printQRIfNecessaryListener = printQRIfNecessaryListener;
 const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://github.com/realvare/baileyz/lib/Defaults/baileys-version.json';
+    const URL = 'https://github.com/realvare/based/lib/Defaults/baileys-version.json';
     try {
         const result = await axios_1.default.get(URL, {
             ...options,

package/lib/Utils/jid-validation.js

@@ -37,8 +37,9 @@ const normalizeJid = (jid) => {
     if (!jid) return jid;
 
     // Convert LID to standard JID format
-    if (jid.endsWith('@lid')) {
-        return jid.replace('@lid', '@s.whatsapp.net');
+    if ((0, WABinary_1.isLid)(jid)) {
+        const converted = (0, WABinary_1.lidToJid)(jid);
+        return converted || jid;
     }
 
     // Ensure consistent format
@@ -119,9 +120,10 @@ const toJid = (lid) => {
     if (!lid) return lid;
 
     try {
-        // Simple conversion from LID to JID format
-        if (lid.endsWith('@lid')) {
-            return lid.replace('@lid', '@s.whatsapp.net');
+        // Convert LID to JID format
+        if ((0, WABinary_1.isLid)(lid)) {
+            const converted = (0, WABinary_1.lidToJid)(lid);
+            return converted || lid;
         }
 
         // If already in JID format, return as-is

package/lib/Utils/messages-media.d.ts

@@ -16,7 +16,7 @@ export declare function vid2jpg(videoUrl: string): Promise<string>;
  * Modified for customization and improvements
  */
 export declare const extractVideoThumb: (videoPath: string) => Promise<Buffer<ArrayBufferLike>>;
-export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number, quality?: number) => Promise<{
     buffer: Buffer<ArrayBufferLike>;
     original: {
         width: number;

package/lib/Utils/messages-media.js

@@ -260,7 +260,7 @@ const extractVideoThumb = async (videoPath, time = '00:00:00', size = { width: 2
     });
 };
 exports.extractVideoThumb = extractVideoThumb;
-const extractImageThumb = async (bufferOrFilePath, width = 32) => {
+const extractImageThumb = async (bufferOrFilePath, width = 32, quality = 50) => {
     if (bufferOrFilePath instanceof stream_1.Readable) {
         bufferOrFilePath = await (0, exports.toBuffer)(bufferOrFilePath);
     }
@@ -272,7 +272,7 @@ const extractImageThumb = async (bufferOrFilePath, width = 32) => {
         height: jimp.getHeight()
     };
     const buffer = await jimp
-        .quality(50)
+        .quality(quality)
         .resize(width, AUTO, RESIZE_BILINEAR)
         .getBufferAsync(MIME_JPEG);
     return {