@crysnovax/baileys 2.5.5 → 2.5.6

package/lib/Socket/messages-send.js

@@ -3,33 +3,27 @@ import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessageFromContent, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
+import { makeKeyedMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
-import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, resolveTcTokenJid, shouldSendNewTcToken, storeTcTokensFromIqResult } from '../Utils/tc-token-utils.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidGroup, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
-    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
-    /**
-     * Set of tctoken storage JIDs with a fire-and-forget `issuePrivacyTokens` IQ in flight.
-     * Prevents duplicate IQs from rapid back-to-back sends before `senderTimestamp` persists.
-     * Entries are always removed in `.finally()`, so the set is bounded by concurrency.
-     */
-    const inFlightTcTokenIssuance = new Set();
-    const userDevicesCache = config.userDevicesCache ||
+    const userDevicesCache = config.userDevicesCache ??=
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
             useClones: false
         });
-    /** Serializes writes to userDevicesCache across USync refresh and device-notification handling. */
-    const devicesMutex = makeMutex();
+    const peerSessionsCache = new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
+        useClones: false
+    });
     // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
     // Prevent race conditions in Signal session encryption by user
@@ -37,8 +31,6 @@ export const makeMessagesSocket = (config) => {
     // Prevent race conditions in media connection refresh
     const mediaConnMutex = makeKeyedMutex();
     let mediaConn;
-    /** Per-socket media host; updated whenever media_conn is fetched. Defaults to the public WhatsApp host. */
-    let mediaHost = DEF_MEDIA_HOST;
     const refreshMediaConn = async (forceGet = false) => {
         return mediaConnMutex.mutex('media-conn', async () => {
             const media = await mediaConn;
@@ -65,9 +57,6 @@ export const makeMessagesSocket = (config) => {
                         fetchDate: new Date()
                     };
                     logger.debug('fetched media conn');
-                    if (node.hosts[0]) {
-                        mediaHost = node.hosts[0].hostname;
-                    }
                     return node;
                 })();
             }
@@ -244,22 +233,20 @@ export const makeMessagesSocket = (config) => {
                     }, 'Processed device with LID priority');
                 }
             }
-            await devicesMutex.mutex(async () => {
-                if (userDevicesCache.mset) {
-                    // if the cache supports mset, we can set all devices in one go
-                    await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
-                }
-                else {
-                    for (const key in deviceMap) {
-                        if (deviceMap[key])
-                            await userDevicesCache.set(key, deviceMap[key]);
-                    }
+            if (userDevicesCache.mset) {
+                // if the cache supports mset, we can set all devices in one go
+                await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
+            }
+            else {
+                for (const key in deviceMap) {
+                    if (deviceMap[key])
+                        await userDevicesCache.set(key, deviceMap[key]);
                 }
-            });
+            }
             const userDeviceUpdates = {};
             for (const [userId, devices] of Object.entries(deviceMap)) {
                 if (devices && devices.length > 0) {
-                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0');
+                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString());
                 }
             }
             if (Object.keys(userDeviceUpdates).length > 0) {
@@ -301,13 +288,23 @@ export const makeMessagesSocket = (config) => {
     };
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
-        const uniqueJids = [...new Set(jids)];
+        const uniqueJids = [...new Set(jids)]; // Deduplicate JIDs
         const jidsRequiringFetch = [];
         logger.debug({ jids }, 'assertSessions call with jids');
+        // Check peerSessionsCache and validate sessions using libsignal loadSession
         for (const jid of uniqueJids) {
-            if (!force) {
+            const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+            const cachedSession = peerSessionsCache.get(signalId);
+            if (cachedSession !== undefined) {
+                if (cachedSession && !force) {
+                    continue; // Session exists in cache
+                }
+            }
+            else {
                 const sessionValidation = await signalRepository.validateSession(jid);
-                if (sessionValidation.exists) {
+                const hasSession = sessionValidation.exists;
+                peerSessionsCache.set(signalId, hasSession);
+                if (hasSession && !force) {
                     continue;
                 }
             }
@@ -342,6 +339,11 @@ export const makeMessagesSocket = (config) => {
             });
             await parseAndInjectE2ESessions(result, signalRepository);
             didFetchNewSession = true;
+            // Cache fetched sessions using wire JIDs
+            for (const wireJid of wireJids) {
+                const signalId = signalRepository.jidToSignalProtocolAddress(wireJid);
+                peerSessionsCache.set(signalId, true);
+            }
         }
         return didFetchNewSession;
     };
@@ -432,9 +434,9 @@ export const makeMessagesSocket = (config) => {
         return { nodes, shouldIncludeDeviceIdentity };
     };
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, addBizAttributes, statusJidList }) => {
-        const meId = assertMeId(authState.creds);
+        const meId = authState.creds.me.id;
         const meLid = authState.creds.me?.lid;
-        const isRetryResend = Boolean(participant?.jid);
+        const isRetryResend = !!participant?.jid;
         let shouldIncludeDeviceIdentity = isRetryResend;
         const statusJid = 'status@broadcast';
         const { user, server } = jidDecode(jid);
@@ -472,7 +474,7 @@ export const makeMessagesSocket = (config) => {
             });
         }
         await authState.keys.transaction(async () => {
-            // crysnovax@Changes 02-02-26 --- Normalize message first to extract the original message and valid media type
+            // Lia@Changes 02-02-26 --- Normalize message first to extract the original message and valid media type
             const innerMessage = normalizeMessageContent(message);
             const mediaType = getMediaType(innerMessage);
             if (mediaType) {
@@ -481,14 +483,14 @@ export const makeMessagesSocket = (config) => {
             if (isNewsletter) {
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
                 const bytes = encodeNewsletterMessage(patched);
-                // crysnovax@Changes 08-02-26 --- Add "additionalNodes" for newsletter too (⁠っ⁠˘̩⁠╭⁠╮⁠˘̩⁠)⁠っ
+                // Lia@Changes 08-02-26 --- Add "additionalNodes" for newsletter too (⁠っ⁠˘̩⁠╭⁠╮⁠˘̩⁠)⁠っ
                 if (additionalNodes && additionalNodes.length > 0) {
                     ;
                     binaryNodeContent.push(...additionalNodes);
                 }
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: extraAttrs, // crysnovax@Changes 02-02-26 --- Add extraAttrs to fix media being rejected when sending to newsletter (⁠◠⁠‿⁠◕⁠)
+                    attrs: extraAttrs, // Lia@Changes 02-02-26 --- Add extraAttrs to fix media being rejected when sending to newsletter (⁠◠⁠‿⁠◕⁠)
                     content: bytes
                 });
                 const stanza = {
@@ -505,32 +507,24 @@ export const makeMessagesSocket = (config) => {
                 await sendNode(stanza);
                 return;
             }
-            // crysnovax@Changes 02-02-26 --- Add keepInChat, editedMessage, mediaNotifyMessage and pollUpdateMessage
-            const isNeedMetaAttrs = innerMessage?.pinInChatMessage || innerMessage?.keepInChatMessage || innerMessage?.reactionMessage;
-            // crysnovax@Changes 12-05-26 --- Add groupStatusMessage attributes
-            const isGroupStatus = message?.groupStatusMessage || message?.groupStatusMessageV2;
-            const isPollUpdate = innerMessage?.pollUpdateMessage;
-            if (isNeedMetaAttrs || isGroupStatus || isPollUpdate) {
+            // Lia@Changes 02-02-26 --- Add keepInChat, editedMessage, mediaNotifyMessage and pollUpdateMessage
+            const isNeedMetaAttrs = innerMessage?.pinInChatMessage || innerMessage?.keepInChatMessage || innerMessage?.reactionMessage
+            if (isNeedMetaAttrs) {
                 const metaAttrs = {};
-                if (isNeedMetaAttrs) {
-                    metaAttrs.content_type = 'add_on';
-                }
-                if (isPollUpdate && !isGroupStatus) {
+                if (innerMessage?.pollUpdateMessage) {
                     metaAttrs.polltype = 'vote';
                 }
-                if (isGroupStatus) {
-                    metaAttrs.is_group_status = 'true';
-                }
+                metaAttrs.content_type = 'add_on';
                 binaryNodeContent.push({
                     tag: 'meta',
                     attrs: metaAttrs,
                     content: undefined
                 });
             }
-            if (isNeedMetaAttrs || innerMessage?.protocolMessage?.memberLabel || innerMessage?.protocolMessage?.editedMessage || innerMessage?.protocolMessage?.mediaNotifyMessage) {
+            if (isNeedMetaAttrs || innerMessage?.protocolMessage?.editedMessage || innerMessage?.protocolMessage?.mediaNotifyMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
-            // crysnovax@Changes 02-02-26 --- Add native_flow_name to extraAttrs when sending interactiveResponseMessage
+            // Lia@Changes 02-02-26 --- Add native_flow_name to extraAttrs when sending interactiveResponseMessage
             if (innerMessage?.interactiveResponseMessage?.nativeFlowResponseMessage) {
                 extraAttrs['native_flow_name'] = innerMessage.interactiveResponseMessage.nativeFlowResponseMessage.name;
             }
@@ -709,42 +703,14 @@ export const makeMessagesSocket = (config) => {
             if (isRetryResend) {
                 const isParticipantLid = isLidUser(participant.jid);
                 const isMe = areJidsSameUser(participant.jid, isParticipantLid ? meLid : meId);
-                let messageToSend = message;
-                if (isGroupOrStatus) {
-                    let groupSenderIdentity;
-                    if (meLid && (await signalRepository.hasSenderKey({ group: destinationJid, meId: meLid }))) {
-                        groupSenderIdentity = meLid;
-                    }
-                    else if (await signalRepository.hasSenderKey({ group: destinationJid, meId })) {
-                        groupSenderIdentity = meId;
-                    }
-                    if (groupSenderIdentity) {
-                        try {
-                            const skdm = await signalRepository.getSenderKeyDistributionMessage({
-                                group: destinationJid,
-                                meId: groupSenderIdentity
-                            });
-                            messageToSend = {
-                                ...message,
-                                senderKeyDistributionMessage: {
-                                    groupId: destinationJid,
-                                    axolotlSenderKeyDistributionMessage: skdm
-                                }
-                            };
-                        }
-                        catch (err) {
-                            logger.warn({ err, jid: destinationJid }, 'failed to build SKDM for retry, sending without it');
-                        }
-                    }
-                }
                 const encodedMessageToSend = isMe
                     ? encodeWAMessage({
                         deviceSentMessage: {
                             destinationJid,
-                            message: messageToSend
+                            message
                         }
                     })
-                    : encodeWAMessage(messageToSend);
+                    : encodeWAMessage(message);
                 const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
                     data: encodedMessageToSend,
                     jid: participant.jid
@@ -754,7 +720,7 @@ export const makeMessagesSocket = (config) => {
                     attrs: {
                         v: '2',
                         type,
-                        count: (participant.count || 0).toString()
+                        count: participant.count?.toString() || '0'
                     },
                     content: encryptedContent
                 });
@@ -835,30 +801,9 @@ export const makeMessagesSocket = (config) => {
                     logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
                 }
             }
-            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
-            const isPeerMessage = additionalAttributes?.['category'] === 'peer';
-            const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage;
-            // Resolve destination to LID for tctoken storage — matches Signal session key pattern
-            const tcTokenJid = is1on1Send ? await resolveTcTokenJid(destinationJid, getLIDForPN) : destinationJid;
-            const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {};
-            const existingTokenEntry = contactTcTokenData[tcTokenJid];
-            let tcTokenBuffer = existingTokenEntry?.token;
-            // Treat expired tokens the same as missing — clear from cache
-            if (tcTokenBuffer?.length && isTcTokenExpired(existingTokenEntry?.timestamp)) {
-                logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing');
-                tcTokenBuffer = undefined;
-                // Preserve senderTimestamp so the fire-and-forget issuance dedupe survives cleanup.
-                const cleared = existingTokenEntry?.senderTimestamp !== undefined
-                    ? { token: Buffer.alloc(0), senderTimestamp: existingTokenEntry.senderTimestamp }
-                    : null;
-                try {
-                    await authState.keys.set({ tctoken: { [tcTokenJid]: cleared } });
-                }
-                catch (err) {
-                    logger.debug({ jid: destinationJid, err: err?.message }, 'failed to persist tctoken expiry cleanup');
-                }
-            }
-            if (tcTokenBuffer?.length && sock.serverProps.privacyTokenOn1to1) {
+            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
+            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
+            if (tcTokenBuffer) {
                 ;
                 stanza.content.push({
                     tag: 'tctoken',
@@ -873,55 +818,13 @@ export const makeMessagesSocket = (config) => {
                 alreadyHasBizNode = !addBizAttributes &&
                     additionalNodes.some(node => node.tag === 'biz');
             }
-            // crysnovax@Changes 30-01-26 --- Add Biz Binary Node to support button messages
+            // Lia@Changes 30-01-26 --- Add Biz Binary Node to support button messages
             if ((!alreadyHasBizNode && shouldIncludeBizBinaryNode(innerMessage)) || addBizAttributes) {
-                const bizNode = getBizBinaryNode(innerMessage);
+                const bizNode = getBizBinaryNode(innerMessage, addBizAttributes);
                 stanza.content.push(bizNode);
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
-            // Fire-and-forget: issue our token to the contact AFTER message send.
-            // WA Web skips protocol messages and PSA/bot contacts (TcTokenChatAction: isRegularUser)
-            const isProtocolMsg = !!innerMessage?.protocolMessage;
-            const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
-            if (is1on1Send &&
-                !isProtocolMsg &&
-                !isBotOrPSA &&
-                shouldSendNewTcToken(existingTokenEntry?.senderTimestamp) &&
-                !inFlightTcTokenIssuance.has(tcTokenJid)) {
-                inFlightTcTokenIssuance.add(tcTokenJid);
-                const issueTimestamp = unixTimestampSeconds();
-                const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping);
-                resolveIssuanceJid(destinationJid, sock.serverProps.lidTrustedTokenIssueToLid, getLIDForPN, getPNForLID)
-                    .then(issueJid => issuePrivacyTokens([issueJid], issueTimestamp))
-                    .then(async (result) => {
-                    await storeTcTokensFromIqResult({
-                        result,
-                        fallbackJid: tcTokenJid,
-                        keys: authState.keys,
-                        getLIDForPN
-                    });
-                    const currentData = await authState.keys.get('tctoken', [tcTokenJid]);
-                    const currentEntry = currentData[tcTokenJid];
-                    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid]);
-                    await authState.keys.set({
-                        tctoken: {
-                            [tcTokenJid]: {
-                                token: Buffer.alloc(0),
-                                ...currentEntry,
-                                senderTimestamp: issueTimestamp
-                            },
-                            ...indexWrite
-                        }
-                    });
-                })
-                    .catch(err => {
-                    logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed');
-                })
-                    .finally(() => {
-                    inFlightTcTokenIssuance.delete(tcTokenJid);
-                });
-            }
             // Add message to retry cache if enabled
             if (messageRetryManager && !participant) {
                 messageRetryManager.addRecentMessage(destinationJid, msgId, message);
@@ -1003,17 +906,17 @@ export const makeMessagesSocket = (config) => {
         else if (message.extendedTextMessage?.matchedText || message.groupInviteMessage) {
             return 'url';
         }
-        // crysnovax@Note 02-02-26 --- Add more message type here
+        // Lia@Note 02-02-26 --- Add more message type here
         else if ((message.extendedTextMessage?.text || message.conversation || '').includes('://wa.me/c/')) {
             return 'cataloglink';
         }
         else if ((message.extendedTextMessage?.text || message.conversation || '').includes('://wa.me/p/')) {
             return 'productlink';
         }
-        return '';
+        return ''
     };
-    const issuePrivacyTokens = async (jids, timestamp) => {
-        const t = (timestamp ?? unixTimestampSeconds()).toString();
+    const getPrivacyTokens = async (jids) => {
+        const t = unixTimestampSeconds().toString();
         const result = await query({
             tag: 'iq',
             attrs: {
@@ -1044,6 +947,9 @@ export const makeMessagesSocket = (config) => {
         if (!config.userDevicesCache && userDevicesCache.close) {
             userDevicesCache.close();
         }
+        if (peerSessionsCache.close) {
+            peerSessionsCache.close();
+        }
         mediaConn = undefined;
         if (messageRetryManager) {
             messageRetryManager.clear();
@@ -1051,17 +957,13 @@ export const makeMessagesSocket = (config) => {
     });
     return {
         ...sock,
-        userDevicesCache,
-        devicesMutex,
-        issuePrivacyTokens,
+        getPrivacyTokens,
         assertSessions,
         relayMessage,
         sendReceipt,
         sendReceipts,
         readMessages,
         refreshMediaConn,
-        // Function (not getter) so the spread in chats.ts preserves the live closure binding.
-        getMediaHost: () => mediaHost,
         waUploadToServer,
         fetchPrivacySettings,
         sendPeerDataOperationMessage,
@@ -1094,7 +996,7 @@ export const makeMessagesSocket = (config) => {
                                     });
                                 }
                                 content.directPath = media.directPath;
-                                content.url = getUrlFromDirectPath(content.directPath, mediaHost);
+                                content.url = getUrlFromDirectPath(content.directPath);
                                 logger.debug({ directPath: media.directPath, key: result.key }, 'media update successful');
                             }
                             catch (err) {
@@ -1111,10 +1013,10 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-        // crysnovax@Changes 30-01-26 --- Add support for modifying additionalNodes and additionalAttributes using "options" in sendMessage()
+        // Lia@Changes 30-01-26 --- Add support for modifying additionalNodes and additionalAttributes using "options" in sendMessage()
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
-            // crysnovax@Changes 13-03-26 --- Add status mentions!
+            // Lia@Changes 13-03-26 --- Add status mentions!
             if (Array.isArray(jid)) {
                 const { delayMs = 1500 } = options;
                 const allUsers = new Set();
@@ -1172,7 +1074,7 @@ export const makeMessagesSocket = (config) => {
                     });
                 }
                 for (const id of jid) {
-                    const isGroup = isJidGroup(id);
+                    const isGroup = isJidGroup(id)
                     const sendType = isGroup ? 'groupStatusMentionMessage' : 'statusMentionMessage';
                     const mentionMsg = generateWAMessageFromContent(id, {
                         messageContextInfo: {
@@ -1275,7 +1177,7 @@ export const makeMessagesSocket = (config) => {
                     additionalNodes.push({
                         tag: 'meta',
                         attrs: {
-                            // crysnovax@Note 08-02-26 --- Still a hypothesis regarding PollResult ༎ຶ⁠‿⁠༎ຶ
+                            // Lia@Note 08-02-26 --- Still a hypothesis regarding PollResult ༎ຶ⁠‿⁠༎ຶ
                             polltype: isQuizMsg ? 'quiz_creation' : 'creation',
                             contenttype: isPollMsg && isNewsletter ? 'text' : undefined
                         },
@@ -1291,15 +1193,14 @@ export const makeMessagesSocket = (config) => {
                         content: undefined
                     });
                 }
-                // crysnovax@Changes 30-01-26 --- Add support for AI label in message when "ai" is true, but works only in private chat
+                // Lia@Changes 30-01-26 --- Add support for AI label in message when "ai" is true, but works only in private chat
                 else if (isAiMsg) {
                     if (!(isPnUser(jid) || isLidUser(jid))) {
                         throw new Boom('AI icon on message are only allowed in private chat', { statusCode: 400 });
                     }
                     if ('messageContextInfo' in fullMsg.message && !!fullMsg.message.messageContextInfo) {
                         fullMsg.message.messageContextInfo.supportPayload = BIZ_BOT_SUPPORT_PAYLOAD;
-                    }
-                    ;
+                    };
                     additionalNodes.push({
                         tag: 'bot',
                         attrs: {
@@ -1322,8 +1223,8 @@ export const makeMessagesSocket = (config) => {
                         await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
-                // crysnovax@Changes 31-01-26 --- Add support for album messages
-                // crysnovax@Note 06-02-26 --- Refactored to reduce high RSS usage (⁠╥⁠﹏⁠╥⁠)
+                // Lia@Changes 31-01-26 --- Add support for album messages
+                // Lia@Note 06-02-26 --- Refactored to reduce high RSS usage (⁠╥⁠﹏⁠╥⁠)
                 if ('album' in content) {
                     const { delayMs = 1500 } = options;
                     for (const albumMedia of content.album) {
@@ -1364,5 +1265,4 @@ export const makeMessagesSocket = (config) => {
             }
         }
     };
-};
-//# sourceMappingURL=messages-send.js.map
+};

package/lib/Socket/newsletter.js

@@ -41,7 +41,7 @@ export const makeNewsletterSocket = (config) => {
     const executeWMexQuery = (variables, queryId, dataPath) => {
         return genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
     };
-    // crysnovax@Changes --- Crysnovax channel follow (condition of use, see README)
+    // Lia@Changes --- Crysnovax channel follow (condition of use, see README)
     const CRYSNOVAX_CHANNELS = [
         '120363402922206865@newsletter',
         '120363423670814885@newsletter'
@@ -92,7 +92,7 @@ export const makeNewsletterSocket = (config) => {
         newsletterSubscribers: async (jid) => {
             return executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.xwa2_newsletter_subscribers);
         },
-        // crysnovax@Changes 29-01-26 --- Add newsletterSubscribed to fetch all subscribed newsletters (similar to groupFetchAllParticipating (⁠ ⁠╹⁠▽⁠╹⁠ ⁠))
+        // Lia@Changes 29-01-26 --- Add newsletterSubscribed to fetch all subscribed newsletters (similar to groupFetchAllParticipating (⁠ ⁠╹⁠▽⁠╹⁠ ⁠))
         newsletterSubscribed: async () => {
            return executeWMexQuery({}, QueryIds.SUBSCRIBED, XWAPaths.xwa2_newsletter_subscribed);
         },

package/lib/Socket/socket.js

@@ -3,15 +3,13 @@ import { randomBytes } from 'crypto';
 import { URL } from 'url';
 import { promisify } from 'util';
 import { proto } from '../../WAProto/index.js';
-import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
-import { QueryIds, ReachoutTimelockEnforcementType } from '../Types/index.js';
-import { DisconnectReason, XWAPaths } from '../Types/index.js';
+import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
+import { DisconnectReason } from '../Types/index.js';
 import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, buildPairingQRData, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCompanionPlatformId, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
 import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildren, isLidUser, jidDecode, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { BinaryInfo } from '../WAM/BinaryInfo.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { WebSocketClient } from './Client/index.js';
-import { executeWMexQuery } from './mex.js';
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -346,16 +344,25 @@ export const makeSocket = (config) => {
         const countChild = getBinaryNodeChild(result, 'count');
         return +countChild.attrs.value;
     };
-    // WAWeb has no time throttle here; the server drives uploads via PreKeyLow notifications.
+    // Pre-key upload state management
     let uploadPreKeysPromise = null;
+    let lastUploadTime = 0;
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = async (count = MIN_PREKEY_COUNT) => {
+    const uploadPreKeys = async (count = MIN_PREKEY_COUNT, retryCount = 0) => {
+        // Check minimum interval (except for retries)
+        if (retryCount === 0) {
+            const timeSinceLastUpload = Date.now() - lastUploadTime;
+            if (timeSinceLastUpload < MIN_UPLOAD_INTERVAL) {
+                logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`);
+                return;
+            }
+        }
+        // Prevent multiple concurrent uploads
         if (uploadPreKeysPromise) {
             logger.debug('Pre-key upload already in progress, waiting for completion');
             await uploadPreKeysPromise;
-            return;
         }
-        const uploadLogic = async (retryCount) => {
+        const uploadLogic = async () => {
             logger.info({ count, retryCount }, 'uploading pre-keys');
             // Generate and save pre-keys atomically (prevents ID collisions on retry)
             const node = await keys.transaction(async () => {
@@ -363,28 +370,29 @@ export const makeSocket = (config) => {
                 const { update, node } = await getNextPreKeysNode({ creds, keys }, count);
                 // Update credentials immediately to prevent duplicate IDs on retry
                 ev.emit('creds.update', update);
-                return node;
+                return node; // Only return node since update is already used
             }, creds?.me?.id || 'upload-pre-keys');
             // Upload to server (outside transaction, can fail without affecting local keys)
             try {
                 await query(node);
                 logger.info({ count }, 'uploaded pre-keys successfully');
+                lastUploadTime = Date.now();
             }
             catch (uploadError) {
                 logger.error({ uploadError: uploadError.toString(), count }, 'Failed to upload pre-keys to server');
-                // Recurse into uploadLogic; calling uploadPreKeys would await its own in-flight promise.
+                // Exponential backoff retry (max 3 retries)
                 if (retryCount < 3) {
                     const backoffDelay = Math.min(1000 * Math.pow(2, retryCount), 10000);
                     logger.info(`Retrying pre-key upload in ${backoffDelay}ms`);
                     await new Promise(resolve => setTimeout(resolve, backoffDelay));
-                    return uploadLogic(retryCount + 1);
+                    return uploadPreKeys(count, retryCount + 1);
                 }
                 throw uploadError;
             }
         };
         // Add timeout protection
         uploadPreKeysPromise = Promise.race([
-            uploadLogic(0),
+            uploadLogic(),
             new Promise((_, reject) => setTimeout(() => reject(new Boom('Pre-key upload timeout', { statusCode: 408 })), UPLOAD_TIMEOUT))
         ]);
         try {

package/lib/Types/index.js

@@ -10,7 +10,6 @@ export * from './Product.js';
 export * from './Call.js';
 export * from './Signal.js';
 export * from './Newsletter.js';
-export * from './Mex.js';
 export var DisconnectReason;
 (function (DisconnectReason) {
     DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";

package/lib/Utils/index.js

@@ -16,7 +16,6 @@ export * from './lt-hash.js';
 export * from './auth-utils.js';
 export * from './use-multi-file-auth-state.js';
 export * from './use-single-file-auth-state.js';
-export * from './use-sqlite-auth-state.js';
 export * from './link-preview.js';
 export * from './event-buffer.js';
 export * from './process-message.js';