@realvare/based 2.7.58 → 2.7.60

package/lib/Defaults/index.js

@@ -33,7 +33,7 @@ exports.PROCESSABLE_HISTORY_TYPES = [
 ];
 exports.DEFAULT_CONNECTION_CONFIG = {
     version: baileys_version_json_1.version,
-    browser: Utils_1.Browsers.ubuntu('Chrome'),
+    browser: Utils_1.Browsers.windows('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
     keepAliveIntervalMs: 30000,
@@ -103,4 +103,4 @@ exports.DEFAULT_CACHE_TTLS = {
     MSG_RETRY: 60 * 60, // 1 hour
     CALL_OFFER: 5 * 60, // 5 minutes
     USER_DEVICES: 5 * 60, // 5 minutes
-};
+};

package/lib/Signal/libsignal.js

@@ -42,17 +42,7 @@ const sender_key_record_1 = require("./Group/sender-key-record");
 const Group_1 = require("./Group");
 function makeLibSignalRepository(auth) {
     const storage = signalStorage(auth);
-    const lidMapping = {
-        get: async (lid) => {
-            const { [lid]: pn } = await auth.keys.get('lid-mapping', [lid]);
-            return pn;
-        },
-        set: (lid, pn) => {
-            return auth.keys.set({ 'lid-mapping': { [lid]: pn } });
-        }
-    };
     return {
-        lidMapping,
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
@@ -117,17 +107,6 @@ function makeLibSignalRepository(auth) {
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
-        },
-        getLidAddress(jid) {
-            const { user, device } = (0, WABinary_1.jidDecode)(jid);
-            return new libsignal.ProtocolAddress(user, device || 0);
-        },
-        getDeviceCanHandleLid() {
-            const { platform, pushname, verifiedName } = auth.creds;
-            if (platform === 'android' || platform === 'ios' || platform === 'smba' || platform === 'smbi') {
-                return true;
-            }
-            return false;
         }
     };
 }
@@ -192,4 +171,4 @@ function signalStorage({ creds, keys }) {
             };
         }
     };
-}
+}

package/lib/Socket/groups.js

@@ -26,7 +26,15 @@ const makeGroupsSocket = (config) => {
     }));
     const groupMetadata = async (jid) => {
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-        return (0, exports.extractGroupMetadata)(result);
+        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);
+                }
+            }
+        }
+        return metadata;
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -331,7 +339,7 @@ const extractGroupMetadata = (result) => {
         participants: (0, WABinary_1.getBinaryNodeChildren)(group, 'participant').map(({ attrs }) => {
             return {
                 id: attrs.jid,
-                jid: attrs.phone_number || (0, WABinary_1.lidToJid)(attrs.jid),
+                jid: attrs.phone_number || attrs.jid,
                 lid: attrs.lid || ((0, WABinary_1.isLid)(attrs.jid) ? attrs.jid : undefined),
                 admin: (attrs.type || null),
             };

package/lib/Socket/index.js

@@ -1,10 +1,23 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
 const Defaults_1 = require("../Defaults");
 const business_1 = require("./business");
 // export the last socket layer
-const makeWASocket = (config) => ((0, business_1.makeBusinessSocket)({
-    ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
-    ...config
-}));
+const makeWASocket = (config) => {
+    config = {
+        ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
+        ...config,
+    };
+    if (!config.lidCache) {
+        config.lidCache = new node_cache_1.default({
+            stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.LID_JID,
+            useClones: false
+        });
+    }
+    return (0, business_1.makeBusinessSocket)(config);
+};
 exports.default = makeWASocket;

package/lib/Socket/messages-recv.js

@@ -253,13 +253,27 @@ const makeMessagesRecvSocket = (config) => {
         }
     };
     const toLidIfNecessary = (jid) => {
-        if (typeof jid !== 'string') return jid;
+        if (typeof jid !== 'string')
+            return jid;
         const [user, server] = jid.split('@');
-        if (server === 's.whatsapp.net' && /^[0-9]+$/.test(user) && user.length >= 15) {
+        if (server === 's.whatsapp.net' && /^[0-9]+$/.test(user) && user.length >= 12) {
             return `${user}@lid`;
         }
         return jid;
     };
+    // Helper for LID resolution in group context
+    const resolveLidFromGroupContext = async (lid, groupJid) => {
+        if (!(0, WABinary_1.isLid)(lid) || !(0, WABinary_1.isJidGroup)(groupJid)) {
+            return lid; // Not a LID or not from a group, no special resolution
+        }
+        const metadata = await groupMetadata(groupJid);
+        const found = metadata.participants.find(p => p.id === lid);
+        let jid = found?.jid;
+        if (!jid) {
+            jid = config.lidCache?.get(lid);
+        }
+        return jid || (0, WABinary_1.lidToJid)(lid); // Fallback to naive if not found
+    };
     const handleGroupNotification = async (participant, child, groupJid, msg) => {
         var _a, _b, _c, _d;
         const participantJid = (((_b = (_a = (0, WABinary_1.getBinaryNodeChild)(child, 'participant')) === null || _a === void 0 ? void 0 : _a.attrs) === null || _b === void 0 ? void 0 : _b.jid) || participant);
@@ -377,35 +391,34 @@ const makeMessagesRecvSocket = (config) => {
         if (msg.key?.participant) {
             msg.key.participant = toLidIfNecessary(msg.key.participant);
         }
-        const needsResolving = (msg.messageStubParameters && msg.messageStubParameters.some(p => typeof p === 'string')) ||
-                               (participant && (0, WABinary_1.isLid)(participant)) ||
-                               (msg.key?.participant && (0, WABinary_1.isLid)(msg.key.participant));
-        if(needsResolving) {
+        const needsResolving = (msg.messageStubParameters && msg.messageStubParameters.some(p => (0, WABinary_1.isLid)(p))) ||
+            (participant && (0, WABinary_1.isLid)(participant)) ||
+            (msg.key?.participant && (0, WABinary_1.isLid)(msg.key.participant));
+        if (needsResolving) {
             const metadata = await groupMetadata(groupJid);
+            const { lidCache } = config;
+            const resolveLid = (lid) => {
+                const found = metadata.participants.find(p => p.id === lid);
+                let jid = found === null || found === void 0 ? void 0 : found.jid;
+                if (!jid) {
+                    jid = lidCache === null || lidCache === void 0 ? void 0 : lidCache.get(lid);
+                }
+                return jid || (0, WABinary_1.lidToJid)(lid);
+            };
             if (msg.messageStubParameters) {
-                msg.messageStubParameters = await Promise.all(msg.messageStubParameters.map(async (param) => {
-                    if (typeof param === 'string') {
-                        if ((0, WABinary_1.isLid)(param)) {
-                            const found = metadata.participants.find(p => p.id === param);
-                            return found?.jid || (0, WABinary_1.lidToJid)(param);
-                        } else {
-                            return param;
-                        }
-                    }
-                    return param;
-                }));
+                msg.messageStubParameters = await Promise.all(msg.messageStubParameters.map(async (param) => (typeof param === 'string' && (0, WABinary_1.isLid)(param) ? await resolveLidFromGroupContext(param, groupJid) : param)));
+            }
+            if ((0, WABinary_1.isLid)(participant)) {
+                msg.participant = await resolveLidFromGroupContext(participant, groupJid);
             }
-            if(participant && (0, WABinary_1.isLid)(participant)) {
-                const found = metadata.participants.find(p => p.id === participant);
-                msg.participant = found?.jid || (0, WABinary_1.lidToJid)(participant);
-            } else if (participant) {
+            else if (participant) {
                 //If it's a JID, treat it as a JID. Do not convert back to LID. *smh brah
                 msg.participant = participant;
             }
-            if (msg.key?.participant && (0, WABinary_1.isLid)(msg.key.participant)) {
-                const found = metadata.participants.find(p => p.id === msg.key.participant);
-                msg.key.participant = found?.jid || (0, WABinary_1.lidToJid)(msg.key.participant);
-            } else if (msg.key?.participant) {
+            if (msg.key && (0, WABinary_1.isLid)(msg.key.participant)) {
+                msg.key.participant = await resolveLidFromGroupContext(msg.key.participant, groupJid);
+            }
+            else if (msg.key && msg.key.participant) {
                 // If it's a JID, treat it as a JID. Do not convert back to LID. *smh brahpt2
                 msg.key.participant = msg.key.participant;
             }
@@ -525,14 +538,11 @@ const makeMessagesRecvSocket = (config) => {
                         ...result.key || {},
                         participant: setPicture === null || setPicture === void 0 ? void 0 : setPicture.attrs.author
                     };
-                    const metadata = await groupMetadata(from);
-                    if (result.participant && result.participant.endsWith('@lid')) {
-                        const found = metadata.participants.find(p => p.id === result.participant);
-                        result.participant = found?.jid || (0, WABinary_1.lidToJid)(result.participant);
+                    if (result.participant && (0, WABinary_1.isLid)(result.participant)) {
+                        result.participant = await resolveLidFromGroupContext(result.participant, from);
                     }
-                    if (result.key?.participant && result.key.participant.endsWith('@lid')) {
-                        const found = metadata.participants.find(p => p.id === result.key.participant);
-                        result.key.participant = found?.jid || (0, WABinary_1.lidToJid)(result.key.participant);
+                    if (result.key?.participant && (0, WABinary_1.isLid)(result.key.participant)) {
+                        result.key.participant = await resolveLidFromGroupContext(result.key.participant, from);
                     }
                 }
                 break;
@@ -684,15 +694,30 @@ const makeMessagesRecvSocket = (config) => {
     const handleReceipt = async (node) => {
         var _a, _b;
         const { attrs, content } = node;
+        let participant = attrs.participant;
+        if (participant && (0, WABinary_1.isLid)(participant) && (0, WABinary_1.isJidGroup)(attrs.from)) {
+            const metadata = await groupMetadata(attrs.from);
+            const found = metadata.participants.find(p => p.id === participant);
+            const jid = found === null || found === void 0 ? void 0 : found.jid;
+            if (jid && !(0, WABinary_1.isLid)(jid)) {
+                participant = jid;
+            }
+            else {
+                const cached = config.lidCache.get(participant);
+                if (cached) {
+                    participant = cached;
+                }
+            }
+        }
         const isLid = attrs.from.includes('lid');
-        const isNodeFromMe = (0, WABinary_1.areJidsSameUser)(resolveJid(attrs.participant) || resolveJid(attrs.from), isLid ? (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.lid : (_b = authState.creds.me) === null || _b === void 0 ? void 0 : _b.id);
+        const isNodeFromMe = (0, WABinary_1.areJidsSameUser)(resolveJid(participant) || resolveJid(attrs.from), isLid ? (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.lid : (_b = authState.creds.me) === null || _b === void 0 ? void 0 : _b.id);
         const remoteJid = !isNodeFromMe || (0, WABinary_1.isJidGroup)(attrs.from) ? resolveJid(attrs.from) : attrs.recipient;
         const fromMe = !attrs.recipient || ((attrs.type === 'retry' || attrs.type === 'sender') && isNodeFromMe);
         const key = {
             remoteJid,
             id: '',
             fromMe,
-            participant: resolveJid(attrs.participant)
+            participant: resolveJid(participant)
         };
         if (shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
             logger.debug({ remoteJid }, 'ignoring receipt from jid');
@@ -845,6 +870,32 @@ const makeMessagesRecvSocket = (config) => {
                 processingMutex.mutex(async () => {
                     var _a, _b, _c, _d, _e, _f;
                     await decrypt();
+                    // if the message is from a group, and contains mentions, resolve the LIDs to JIDs
+                    if ((0, WABinary_1.isJidGroup)(msg.key.remoteJid)) {
+                        const contextInfo = msg.message?.extendedTextMessage?.contextInfo;
+                        if (contextInfo) {
+                            const participant = contextInfo.participant;
+                            const mentionedJid = contextInfo.mentionedJid;
+                            const hasLidInParticipant = participant && participant.endsWith('@lid');
+                            const hasLidInMention = mentionedJid && mentionedJid.some(j => j.endsWith('@lid'));
+                            if (hasLidInParticipant || hasLidInMention) {
+                                const metadata = await groupMetadata(msg.key.remoteJid);
+                                if (hasLidInParticipant) {
+                                    const found = metadata.participants.find(p => p.id === participant);
+                                    contextInfo.participant = (found?.jid) || participant;
+                                }
+                                if (hasLidInMention) {
+                                    contextInfo.mentionedJid = await Promise.all(mentionedJid.map(async (jid) => {
+                                        if (jid.endsWith('@lid')) {
+                                            const found = metadata.participants.find(p => p.id === jid);
+                                            return (found?.jid) || jid;
+                                        }
+                                        return jid;
+                                    }));
+                                }
+                            }
+                        }
+                    }
                     // message failed to decrypt
                     if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
                         if (((_a = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]) === Utils_1.MISSING_KEYS_ERROR_TEXT) {
@@ -872,14 +923,6 @@ const makeMessagesRecvSocket = (config) => {
                         if ((_b = msg.key.participant) === null || _b === void 0 ? void 0 : _b.endsWith('@lid')) {
                             msg.key.participant = node.attrs.participant_pn || authState.creds.me.id;
                         }
-                        if ((0, WABinary_1.isJidGroup)(msg.key.remoteJid) && ((_f = (_e = (_d = (_c = msg.message) === null || _c === void 0 ? void 0 : _c.extendedTextMessage) === null || _d === void 0 ? void 0 : _d.contextInfo) === null || _e === void 0 ? void 0 : _e.participant) === null || _f === void 0 ? void 0 : _f.endsWith('@lid'))) {
-                            if (msg.message.extendedTextMessage.contextInfo) {
-                                const metadata = await groupMetadata(msg.key.remoteJid);
-                                const sender = msg.message.extendedTextMessage.contextInfo.participant;
-                                const found = metadata.participants.find(p => p.id === sender);
-                                msg.message.extendedTextMessage.contextInfo.participant = (found === null || found === void 0 ? void 0 : found.jid) || sender;
-                            }
-                        }
                         if (!(0, WABinary_1.isJidGroup)(msg.key.remoteJid) && (0, WABinary_1.isLidUser)(msg.key.remoteJid)) {
                             msg.key.remoteJid = node.attrs.sender_pn || node.attrs.peer_recipient_pn;
                         }
@@ -966,11 +1009,15 @@ const makeMessagesRecvSocket = (config) => {
         const { attrs } = node;
         const [infoChild] = (0, WABinary_1.getAllBinaryNodeChildren)(node);
         const callId = infoChild.attrs['call-id'];
-        const from = resolveJid(infoChild.attrs.from || infoChild.attrs['call-creator']);
         const status = (0, Utils_1.getCallStatusFromNode)(infoChild);
+        // Determine the group JID context for resolution
+        const contextGroupJid = (0, WABinary_1.isJidGroup)(attrs.from) ? attrs.from : undefined;
+        // Resolve JIDs using the new helper
+        const resolvedCallCreator = await resolveLidFromGroupContext(infoChild.attrs.from || infoChild.attrs['call-creator'], contextGroupJid);
+        const resolvedChatId = await resolveLidFromGroupContext(attrs.from, contextGroupJid);
         const call = {
-            chatId: resolveJid(attrs.from),
-            from,
+            chatId: resolvedChatId,
+            from: resolvedCallCreator,
             id: callId,
             date: new Date(+attrs.t * 1000),
             offline: !!attrs.offline,
@@ -979,7 +1026,10 @@ const makeMessagesRecvSocket = (config) => {
         if (status === 'offer') {
             call.isVideo = !!(0, WABinary_1.getBinaryNodeChild)(infoChild, 'video');
             call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
-            call.groupJid = resolveJid(infoChild.attrs['group-jid']);
+            // resolve infoChild.attrs['group-jid'] if it's a LID
+            if (infoChild.attrs['group-jid']) {
+                call.groupJid = await resolveLidFromGroupContext(infoChild.attrs['group-jid'], infoChild.attrs['group-jid']);
+            }
             callOfferCache.set(call.id, call);
         }
         const existingCall = callOfferCache.get(call.id);

package/lib/Socket/socket.js

@@ -130,14 +130,7 @@ const makeSocket = (config) => {
                 // ignore
             }
         }
-        // gently back off when encountering rate limits (429)
-        if (message.includes('429') || message.includes('rate limit')) {
-            const wait = Math.min(30000, (config.backoffDelayMs || 5000));
-            logger.info({ wait }, 'backing off due to rate limit');
-            setTimeout(() => {
-                // intentionally empty; wait to delay further sends
-            }, wait);
-        }
+
     };
     /** await the next incoming message */
     const awaitNextMessage = async (sendMsg) => {
@@ -192,15 +185,40 @@ 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 initialDelay = config.retryRequestDelayMs;
+        while (retries < maxRetries) {
+            try {
+                return await task();
+            } 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
+                    logger.warn({ error, retries, delayMs }, `Rate limit hit for ${errorStr}. Retrying in ${delayMs}ms...`);
+                    await (0, Utils_1.delay)(delayMs);
+                } else {
+                    throw error; // Re-throw other errors immediately
+                }
+            }
+        }
+        throw new boom_1.Boom(`Failed to ${errorStr} after ${maxRetries} retries due to rate limits`, { statusCode: Types_1.DisconnectReason.rateLimit });
+    };
+
     const query = async (node, timeoutMs) => {
         if (!node.attrs.id) {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
-        const [result] = await Promise.all([
-            waitForMessage(msgId, timeoutMs),
-            sendNode(node)
-        ]);
+
+        const [result] = await waCallAndRetry(async () => {
+            return await Promise.all([
+                waitForMessage(msgId, timeoutMs),
+                sendNode(node)
+            ]);
+        }, `query ${msgId}`);
+        
         if ('tag' in result) {
             (0, WABinary_1.assertNodeErrorFree)(result);
         }

package/lib/Types/index.d.ts

@@ -32,7 +32,8 @@ export declare enum DisconnectReason {
     restartRequired = 515,
     multideviceMismatch = 411,
     forbidden = 403,
-    unavailableService = 503
+    unavailableService = 503,
+    rateLimit = 429
 }
 export type WAInitResponse = {
     ref: string;

package/lib/Types/index.js

@@ -39,4 +39,5 @@ var DisconnectReason;
     DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
     DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
     DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
+    DisconnectReason[DisconnectReason["rateLimit"] = 429] = "rateLimit";
 })(DisconnectReason || (exports.DisconnectReason = DisconnectReason = {}));

package/lib/Utils/process-message.js

@@ -130,25 +130,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         }
     }
     const content = (0, messages_1.normalizeMessageContent)(message.message);
-    const senderId = message.key.participant || message.key.remoteJid;
-    if ((0, WABinary_1.isLidUser)(senderId)) {
-        const jid = (0, WABinary_1.lidToJid)(senderId);
-        if (message.key.participant) {
-            message.key.participant = jid;
-        }
-        else {
-            message.key.remoteJid = jid;
-        }
-    }
-    const mJids = content && content.contextInfo && content.contextInfo.mentionedJid ? content.contextInfo.mentionedJid : [];
-    for (let i = 0; i < mJids.length; i++) {
-        if ((0, WABinary_1.isLidUser)(mJids[i])) {
-            mJids[i] = (0, WABinary_1.lidToJid)(mJids[i]);
-        }
-    }
-    if (content && content.contextInfo && content.contextInfo.participant && (0, WABinary_1.isLidUser)(content.contextInfo.participant)) {
-        content.contextInfo.participant = (0, WABinary_1.lidToJid)(content.contextInfo.participant);
-    }
+
     // unarchive chat if it's a real message, or someone reacted to our message
     // and we've the unarchive chats setting on
     if ((isRealMsg || ((_b = (_a = content === null || content === void 0 ? void 0 : content.reactionMessage) === null || _a === void 0 ? void 0 : _a.key) === null || _b === void 0 ? void 0 : _b.fromMe))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realvare/based",
-  "version": "2.7.58",
+  "version": "2.7.60",
   "description": "whatsapp api by sam",
   "keywords": [
     "baileys",