@crysnovax/baileys 2.5.0 → 2.5.5

package/lib/Socket/messages-send.js

@@ -3,27 +3,33 @@ 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, 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 { 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 { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { makeKeyedMutex } from '../Utils/make-mutex.js';
+import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidGroup, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.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 { 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 userDevicesCache = config.userDevicesCache ??=
+    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 ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
             useClones: false
         });
-    const peerSessionsCache = new NodeCache({
-        stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
-        useClones: false
-    });
+    /** Serializes writes to userDevicesCache across USync refresh and device-notification handling. */
+    const devicesMutex = makeMutex();
     // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
     // Prevent race conditions in Signal session encryption by user
@@ -31,6 +37,8 @@ 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;
@@ -57,6 +65,9 @@ export const makeMessagesSocket = (config) => {
                         fetchDate: new Date()
                     };
                     logger.debug('fetched media conn');
+                    if (node.hosts[0]) {
+                        mediaHost = node.hosts[0].hostname;
+                    }
                     return node;
                 })();
             }
@@ -233,20 +244,22 @@ export const makeMessagesSocket = (config) => {
                     }, 'Processed device with LID priority');
                 }
             }
-            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]);
+            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]);
+                    }
+                }
+            });
             const userDeviceUpdates = {};
             for (const [userId, devices] of Object.entries(deviceMap)) {
                 if (devices && devices.length > 0) {
-                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString());
+                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0');
                 }
             }
             if (Object.keys(userDeviceUpdates).length > 0) {
@@ -288,23 +301,13 @@ export const makeMessagesSocket = (config) => {
     };
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
-        const uniqueJids = [...new Set(jids)]; // Deduplicate JIDs
+        const uniqueJids = [...new Set(jids)];
         const jidsRequiringFetch = [];
         logger.debug({ jids }, 'assertSessions call with jids');
-        // Check peerSessionsCache and validate sessions using libsignal loadSession
         for (const jid of uniqueJids) {
-            const signalId = signalRepository.jidToSignalProtocolAddress(jid);
-            const cachedSession = peerSessionsCache.get(signalId);
-            if (cachedSession !== undefined) {
-                if (cachedSession && !force) {
-                    continue; // Session exists in cache
-                }
-            }
-            else {
+            if (!force) {
                 const sessionValidation = await signalRepository.validateSession(jid);
-                const hasSession = sessionValidation.exists;
-                peerSessionsCache.set(signalId, hasSession);
-                if (hasSession && !force) {
+                if (sessionValidation.exists) {
                     continue;
                 }
             }
@@ -339,11 +342,6 @@ 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;
     };
@@ -434,9 +432,9 @@ export const makeMessagesSocket = (config) => {
         return { nodes, shouldIncludeDeviceIdentity };
     };
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, addBizAttributes, statusJidList }) => {
-        const meId = authState.creds.me.id;
+        const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
-        const isRetryResend = !!participant?.jid;
+        const isRetryResend = Boolean(participant?.jid);
         let shouldIncludeDeviceIdentity = isRetryResend;
         const statusJid = 'status@broadcast';
         const { user, server } = jidDecode(jid);
@@ -474,7 +472,7 @@ export const makeMessagesSocket = (config) => {
             });
         }
         await authState.keys.transaction(async () => {
-            // Lia@Changes 02-02-26 --- Normalize message first to extract the original message and valid media type
+            // crysnovax@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) {
@@ -483,14 +481,14 @@ export const makeMessagesSocket = (config) => {
             if (isNewsletter) {
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
                 const bytes = encodeNewsletterMessage(patched);
-                // Lia@Changes 08-02-26 --- Add "additionalNodes" for newsletter too (⁠っ⁠˘̩⁠╭⁠╮⁠˘̩⁠)⁠っ
+                // crysnovax@Changes 08-02-26 --- Add "additionalNodes" for newsletter too (⁠っ⁠˘̩⁠╭⁠╮⁠˘̩⁠)⁠っ
                 if (additionalNodes && additionalNodes.length > 0) {
                     ;
                     binaryNodeContent.push(...additionalNodes);
                 }
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: extraAttrs, // Lia@Changes 02-02-26 --- Add extraAttrs to fix media being rejected when sending to newsletter (⁠◠⁠‿⁠◕⁠)
+                    attrs: extraAttrs, // crysnovax@Changes 02-02-26 --- Add extraAttrs to fix media being rejected when sending to newsletter (⁠◠⁠‿⁠◕⁠)
                     content: bytes
                 });
                 const stanza = {
@@ -507,24 +505,32 @@ export const makeMessagesSocket = (config) => {
                 await sendNode(stanza);
                 return;
             }
-            // Lia@Changes 02-02-26 --- Add keepInChat, editedMessage, mediaNotifyMessage and pollUpdateMessage
-            const isNeedMetaAttrs = innerMessage?.pinInChatMessage || innerMessage?.keepInChatMessage || innerMessage?.reactionMessage
-            if (isNeedMetaAttrs) {
+            // 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) {
                 const metaAttrs = {};
-                if (innerMessage?.pollUpdateMessage) {
+                if (isNeedMetaAttrs) {
+                    metaAttrs.content_type = 'add_on';
+                }
+                if (isPollUpdate && !isGroupStatus) {
                     metaAttrs.polltype = 'vote';
                 }
-                metaAttrs.content_type = 'add_on';
+                if (isGroupStatus) {
+                    metaAttrs.is_group_status = 'true';
+                }
                 binaryNodeContent.push({
                     tag: 'meta',
                     attrs: metaAttrs,
                     content: undefined
                 });
             }
-            if (isNeedMetaAttrs || innerMessage?.protocolMessage?.editedMessage || innerMessage?.protocolMessage?.mediaNotifyMessage) {
+            if (isNeedMetaAttrs || innerMessage?.protocolMessage?.memberLabel || innerMessage?.protocolMessage?.editedMessage || innerMessage?.protocolMessage?.mediaNotifyMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
-            // Lia@Changes 02-02-26 --- Add native_flow_name to extraAttrs when sending interactiveResponseMessage
+            // crysnovax@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;
             }
@@ -703,14 +709,42 @@ 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
+                            message: messageToSend
                         }
                     })
-                    : encodeWAMessage(message);
+                    : encodeWAMessage(messageToSend);
                 const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
                     data: encodedMessageToSend,
                     jid: participant.jid
@@ -720,7 +754,7 @@ export const makeMessagesSocket = (config) => {
                     attrs: {
                         v: '2',
                         type,
-                        count: participant.count?.toString() || '0'
+                        count: (participant.count || 0).toString()
                     },
                     content: encryptedContent
                 });
@@ -801,9 +835,30 @@ export const makeMessagesSocket = (config) => {
                     logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
                 }
             }
-            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
-            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
-            if (tcTokenBuffer) {
+            // 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) {
                 ;
                 stanza.content.push({
                     tag: 'tctoken',
@@ -818,13 +873,55 @@ export const makeMessagesSocket = (config) => {
                 alreadyHasBizNode = !addBizAttributes &&
                     additionalNodes.some(node => node.tag === 'biz');
             }
-            // Lia@Changes 30-01-26 --- Add Biz Binary Node to support button messages
+            // crysnovax@Changes 30-01-26 --- Add Biz Binary Node to support button messages
             if ((!alreadyHasBizNode && shouldIncludeBizBinaryNode(innerMessage)) || addBizAttributes) {
-                const bizNode = getBizBinaryNode(innerMessage, addBizAttributes);
+                const bizNode = getBizBinaryNode(innerMessage);
                 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);
@@ -906,17 +1003,17 @@ export const makeMessagesSocket = (config) => {
         else if (message.extendedTextMessage?.matchedText || message.groupInviteMessage) {
             return 'url';
         }
-        // Lia@Note 02-02-26 --- Add more message type here
+        // crysnovax@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 getPrivacyTokens = async (jids) => {
-        const t = unixTimestampSeconds().toString();
+    const issuePrivacyTokens = async (jids, timestamp) => {
+        const t = (timestamp ?? unixTimestampSeconds()).toString();
         const result = await query({
             tag: 'iq',
             attrs: {
@@ -947,9 +1044,6 @@ export const makeMessagesSocket = (config) => {
         if (!config.userDevicesCache && userDevicesCache.close) {
             userDevicesCache.close();
         }
-        if (peerSessionsCache.close) {
-            peerSessionsCache.close();
-        }
         mediaConn = undefined;
         if (messageRetryManager) {
             messageRetryManager.clear();
@@ -957,13 +1051,17 @@ export const makeMessagesSocket = (config) => {
     });
     return {
         ...sock,
-        getPrivacyTokens,
+        userDevicesCache,
+        devicesMutex,
+        issuePrivacyTokens,
         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,
@@ -996,7 +1094,7 @@ export const makeMessagesSocket = (config) => {
                                     });
                                 }
                                 content.directPath = media.directPath;
-                                content.url = getUrlFromDirectPath(content.directPath);
+                                content.url = getUrlFromDirectPath(content.directPath, mediaHost);
                                 logger.debug({ directPath: media.directPath, key: result.key }, 'media update successful');
                             }
                             catch (err) {
@@ -1013,10 +1111,10 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-        // Lia@Changes 30-01-26 --- Add support for modifying additionalNodes and additionalAttributes using "options" in sendMessage()
+        // crysnovax@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;
-            // Lia@Changes 13-03-26 --- Add status mentions!
+            // crysnovax@Changes 13-03-26 --- Add status mentions!
             if (Array.isArray(jid)) {
                 const { delayMs = 1500 } = options;
                 const allUsers = new Set();
@@ -1074,7 +1172,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: {
@@ -1177,7 +1275,7 @@ export const makeMessagesSocket = (config) => {
                     additionalNodes.push({
                         tag: 'meta',
                         attrs: {
-                            // Lia@Note 08-02-26 --- Still a hypothesis regarding PollResult ༎ຶ⁠‿⁠༎ຶ
+                            // crysnovax@Note 08-02-26 --- Still a hypothesis regarding PollResult ༎ຶ⁠‿⁠༎ຶ
                             polltype: isQuizMsg ? 'quiz_creation' : 'creation',
                             contenttype: isPollMsg && isNewsletter ? 'text' : undefined
                         },
@@ -1193,14 +1291,15 @@ export const makeMessagesSocket = (config) => {
                         content: undefined
                     });
                 }
-                // Lia@Changes 30-01-26 --- Add support for AI label in message when "ai" is true, but works only in private chat
+                // crysnovax@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: {
@@ -1223,8 +1322,8 @@ export const makeMessagesSocket = (config) => {
                         await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
-                // Lia@Changes 31-01-26 --- Add support for album messages
-                // Lia@Note 06-02-26 --- Refactored to reduce high RSS usage (⁠╥⁠﹏⁠╥⁠)
+                // crysnovax@Changes 31-01-26 --- Add support for album messages
+                // crysnovax@Note 06-02-26 --- Refactored to reduce high RSS usage (⁠╥⁠﹏⁠╥⁠)
                 if ('album' in content) {
                     const { delayMs = 1500 } = options;
                     for (const albumMedia of content.album) {
@@ -1265,4 +1364,5 @@ 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);
     };
-    // Lia@Changes --- Crysnovax channel follow (condition of use, see README)
+    // crysnovax@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);
         },
-        // Lia@Changes 29-01-26 --- Add newsletterSubscribed to fetch all subscribed newsletters (similar to groupFetchAllParticipating (⁠ ⁠╹⁠▽⁠╹⁠ ⁠))
+        // crysnovax@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,13 +3,15 @@ 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, MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/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 { 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)
@@ -344,25 +346,16 @@ export const makeSocket = (config) => {
         const countChild = getBinaryNodeChild(result, 'count');
         return +countChild.attrs.value;
     };
-    // Pre-key upload state management
+    // WAWeb has no time throttle here; the server drives uploads via PreKeyLow notifications.
     let uploadPreKeysPromise = null;
-    let lastUploadTime = 0;
     /** generates and uploads a set of pre-keys to the server */
-    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
+    const uploadPreKeys = async (count = MIN_PREKEY_COUNT) => {
         if (uploadPreKeysPromise) {
             logger.debug('Pre-key upload already in progress, waiting for completion');
             await uploadPreKeysPromise;
+            return;
         }
-        const uploadLogic = async () => {
+        const uploadLogic = async (retryCount) => {
             logger.info({ count, retryCount }, 'uploading pre-keys');
             // Generate and save pre-keys atomically (prevents ID collisions on retry)
             const node = await keys.transaction(async () => {
@@ -370,29 +363,28 @@ 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; // Only return node since update is already used
+                return node;
             }, 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');
-                // Exponential backoff retry (max 3 retries)
+                // Recurse into uploadLogic; calling uploadPreKeys would await its own in-flight promise.
                 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 uploadPreKeys(count, retryCount + 1);
+                    return uploadLogic(retryCount + 1);
                 }
                 throw uploadError;
             }
         };
         // Add timeout protection
         uploadPreKeysPromise = Promise.race([
-            uploadLogic(),
+            uploadLogic(0),
             new Promise((_, reject) => setTimeout(() => reject(new Boom('Pre-key upload timeout', { statusCode: 408 })), UPLOAD_TIMEOUT))
         ]);
         try {

package/lib/Socket//342/230/201/357/270/216

@@ -0,0 +1 @@
+

package/lib/Types/Mex.js

@@ -0,0 +1,39 @@
+export var XWAPaths;
+(function (XWAPaths) {
+    XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
+    XWAPaths["xwa2_newsletter_subscribers"] = "xwa2_newsletter_subscribers";
+    XWAPaths["xwa2_newsletter_subscribed"] = "xwa2_newsletter_subscribed";
+    XWAPaths["xwa2_newsletter_view"] = "xwa2_newsletter_view";
+    XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
+    XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
+    XWAPaths["xwa2_newsletter_mute_v2"] = "xwa2_newsletter_mute_v2";
+    XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
+    XWAPaths["xwa2_newsletter_follow"] = "xwa2_newsletter_follow";
+    XWAPaths["xwa2_newsletter_unfollow"] = "xwa2_newsletter_unfollow";
+    XWAPaths["xwa2_newsletter_join_v2"] = "xwa2_newsletter_join_v2";
+    XWAPaths["xwa2_newsletter_leave_v2"] = "xwa2_newsletter_leave_v2";
+    XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
+    XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_demote";
+    XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+    XWAPaths["xwa2_fetch_account_reachout_timelock"] = "xwa2_fetch_account_reachout_timelock";
+    XWAPaths["xwa2_message_capping_info"] = "xwa2_message_capping_info";
+})(XWAPaths || (XWAPaths = {}));
+export var QueryIds;
+(function (QueryIds) {
+    QueryIds["CREATE"] = "8823471724422422";
+    QueryIds["UPDATE_METADATA"] = "24250201037901610";
+    QueryIds["METADATA"] = "6563316087068696";
+    QueryIds["SUBSCRIBERS"] = "9783111038412085";
+    QueryIds["SUBSCRIBED"] = "6388546374527196";
+    QueryIds["FOLLOW"] = "24404358912487870";
+    QueryIds["UNFOLLOW"] = "9767147403369991";
+    QueryIds["MUTE"] = "29766401636284406";
+    QueryIds["UNMUTE"] = "9864994326891137";
+    QueryIds["ADMIN_COUNT"] = "7130823597031706";
+    QueryIds["CHANGE_OWNER"] = "7341777602580933";
+    QueryIds["DEMOTE"] = "6551828931592903";
+    QueryIds["DELETE"] = "30062808666639665";
+    QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+    QueryIds["MESSAGE_CAPPING_INFO"] = "24503548349331633";
+})(QueryIds || (QueryIds = {}));
+//# sourceMappingURL=Mex.js.map

package/lib/Types/index.js

@@ -10,6 +10,7 @@ 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/Types//342/234/206

@@ -0,0 +1 @@
+

package/lib/Utils/index.js

@@ -16,6 +16,7 @@ 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';