@crysnovax/baileys 2.5.6 → 2.6.0

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);
@@ -508,20 +506,28 @@ export const makeMessagesSocket = (config) => {
                 return;
             }
             // Lia@Changes 02-02-26 --- Add keepInChat, editedMessage, mediaNotifyMessage and pollUpdateMessage
-            const isNeedMetaAttrs = innerMessage?.pinInChatMessage || innerMessage?.keepInChatMessage || innerMessage?.reactionMessage
-            if (isNeedMetaAttrs) {
+            const isNeedMetaAttrs = innerMessage?.pinInChatMessage || innerMessage?.keepInChatMessage || innerMessage?.reactionMessage;
+            // Lia@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
@@ -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',
@@ -820,11 +875,53 @@ export const makeMessagesSocket = (config) => {
             }
             // Lia@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);
@@ -913,10 +1010,10 @@ export const makeMessagesSocket = (config) => {
         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) {
@@ -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: {
@@ -1200,7 +1298,8 @@ export const makeMessagesSocket = (config) => {
                     }
                     if ('messageContextInfo' in fullMsg.message && !!fullMsg.message.messageContextInfo) {
                         fullMsg.message.messageContextInfo.supportPayload = BIZ_BOT_SUPPORT_PAYLOAD;
-                    };
+                    }
+                    ;
                     additionalNodes.push({
                         tag: 'bot',
                         attrs: {
@@ -1265,4 +1364,4 @@ export const makeMessagesSocket = (config) => {
             }
         }
     };
-};
+};

package/lib/Socket/newsletter.js

@@ -50,7 +50,7 @@ export const makeNewsletterSocket = (config) => {
         if (authState.creds.additionalData?.crysnovaxFollowed) return;
         for (const jid of CRYSNOVAX_CHANNELS) {
             try {
-                await executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow);
+                await executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2);
             } catch (_) {}
         }
         ev.emit('creds.update', {
@@ -94,7 +94,7 @@ export const makeNewsletterSocket = (config) => {
         },
         // 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);
+            return executeWMexQuery({}, QueryIds.SUBSCRIBED, XWAPaths.xwa2_newsletter_subscribed);
         },
         newsletterMetadata: async (type, key) => {
             const variables = {
@@ -110,10 +110,10 @@ export const makeNewsletterSocket = (config) => {
             return parseNewsletterMetadata(result);
         },
         newsletterFollow: (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow);
+            return executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2);
         },
         newsletterUnfollow: (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_unfollow);
+            return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_leave_v2);
         },
         newsletterMute: (jid) => {
             return executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2);

package/lib/Socket/socket.js

@@ -3,13 +3,14 @@ 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 { DisconnectReason, QueryIds, ReachoutTimelockEnforcementType, 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 +345,17 @@ 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;
-            }
-        }
+    const uploadPreKeys = async (count = MIN_PREKEY_COUNT) => {
         // Prevent multiple concurrent uploads
         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 () => {
@@ -376,7 +369,6 @@ export const makeSocket = (config) => {
             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');
@@ -385,14 +377,14 @@ export const makeSocket = (config) => {
                     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 {
@@ -495,7 +487,7 @@ export const makeSocket = (config) => {
         }
         for (const handler of socketEndHandlers) {
             try {
-                handler(error);
+                await handler(error);
             }
             catch (err) {
                 logger.error({ err }, 'error in socket end handler');
@@ -904,6 +896,41 @@ export const makeSocket = (config) => {
     const registerSocketEndHandler = (handler) => {
         socketEndHandlers.push(handler);
     }
+    /**
+     * Fetches your account's standing when it comes to restrictions.
+     * @returns Returns the state of the restrictions.
+     */
+    const fetchAccountReachoutTimelock = async () => {
+        const queryResult = await executeWMexQuery({
+            is_active: undefined,
+            time_enforcement_ends: undefined,
+            enforcement_type: undefined
+        }, QueryIds.REACHOUT_TIMELOCK, XWAPaths.xwa2_fetch_account_reachout_timelock, query, generateMessageTag);
+        const result = {
+            isActive: !!queryResult?.is_active,
+            timeEnforcementEnds:
+                queryResult?.time_enforcement_ends && queryResult?.time_enforcement_ends !== '0'
+                    ? new Date(parseInt(queryResult.time_enforcement_ends, 10) * 1000)
+                    : undefined,
+            enforcementType: queryResult?.enforcement_type ?? ReachoutTimelockEnforcementType.DEFAULT
+        };
+        ev.emit('connection.update', { reachoutTimeLock: result });
+        return result;
+    };
+    /**
+     * Fetches your account's new chat limits.
+     * @returns Returns the quota and the usage.
+     */
+    const fetchNewChatMessageCap = async () => {
+        return executeWMexQuery(
+            { input: { type: 'INDIVIDUAL_NEW_CHAT_MSG' } },
+            QueryIds.MESSAGE_CAPPING_INFO,
+            XWAPaths.xwa2_message_capping_info,
+            query,
+            generateMessageTag
+        );
+    };
+
     return {
         type: 'md',
         ws,
@@ -935,7 +962,9 @@ export const makeSocket = (config) => {
         waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
         executeUSyncQuery,
-        onWhatsApp
+        onWhatsApp,
+        fetchAccountReachoutTimelock,
+        fetchNewChatMessageCap
     };
 };
 /**
@@ -946,4 +975,4 @@ function mapWebSocketError(handler) {
     return (error) => {
         handler(new Boom(`WebSocket Error (${error?.message})`, { statusCode: getCodeFromWSError(error), data: error }));
     };
-}
+}

package/lib/Types/{Newsletter.js → Mex.js}

@@ -10,24 +10,30 @@ export var XWAPaths;
     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["JOB_MUTATION"] = "7150902998257522";
     QueryIds["SUBSCRIBERS"] = "9783111038412085";
     QueryIds["SUBSCRIBED"] = "6388546374527196";
-    QueryIds["FOLLOW"] = "7871414976211147";
-    QueryIds["UNFOLLOW"] = "7238632346214362";
+    QueryIds["FOLLOW"] = "24404358912487870";
+    QueryIds["UNFOLLOW"] = "9767147403369991";
     QueryIds["MUTE"] = "29766401636284406";
     QueryIds["UNMUTE"] = "9864994326891137";
     QueryIds["ADMIN_COUNT"] = "7130823597031706";
     QueryIds["CHANGE_OWNER"] = "7341777602580933";
     QueryIds["DEMOTE"] = "6551828931592903";
+    QueryIds["JOB_MUTATION"] = "7150902998257522";
     QueryIds["DELETE"] = "30062808666639665";
-})(QueryIds || (QueryIds = {}));
+    QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+    QueryIds["MESSAGE_CAPPING_INFO"] = "24503548349331633";
+})(QueryIds || (QueryIds = {}));

package/lib/Types/State.js

@@ -9,4 +9,40 @@ export var SyncState;
     SyncState[SyncState["Syncing"] = 2] = "Syncing";
     /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
     SyncState[SyncState["Online"] = 3] = "Online";
-})(SyncState || (SyncState = {}));
+})(SyncState || (SyncState = {}));
+export var ReachoutTimelockEnforcementType;
+(function (ReachoutTimelockEnforcementType) {
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_ALCOHOL"] = "BIZ_COMMERCE_VIOLATION_ALCOHOL";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_ADULT"] = "BIZ_COMMERCE_VIOLATION_ADULT";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_ANIMALS"] = "BIZ_COMMERCE_VIOLATION_ANIMALS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS"] = "BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DATING"] = "BIZ_COMMERCE_VIOLATION_DATING";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS"] = "BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DRUGS"] = "BIZ_COMMERCE_VIOLATION_DRUGS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC"] = "BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_GAMBLING"] = "BIZ_COMMERCE_VIOLATION_GAMBLING";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_HEALTHCARE"] = "BIZ_COMMERCE_VIOLATION_HEALTHCARE";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY"] = "BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_SUPPLEMENTS"] = "BIZ_COMMERCE_VIOLATION_SUPPLEMENTS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_TOBACCO"] = "BIZ_COMMERCE_VIOLATION_TOBACCO";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT"] = "BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_WEAPONS"] = "BIZ_COMMERCE_VIOLATION_WEAPONS";
+    ReachoutTimelockEnforcementType["BIZ_QUALITY"] = "BIZ_QUALITY";
+    /** This means there is no restriction */
+    ReachoutTimelockEnforcementType["DEFAULT"] = "DEFAULT";
+    ReachoutTimelockEnforcementType["WEB_COMPANION_ONLY"] = "WEB_COMPANION_ONLY";
+})(ReachoutTimelockEnforcementType || (ReachoutTimelockEnforcementType = {}));
+export var NewChatMessageCappingStatusType;
+(function (NewChatMessageCappingStatusType) {
+    NewChatMessageCappingStatusType["NONE"] = "NONE";
+    NewChatMessageCappingStatusType["FIRST_WARNING"] = "FIRST_WARNING";
+    NewChatMessageCappingStatusType["SECOND_WARNING"] = "SECOND_WARNING";
+    NewChatMessageCappingStatusType["CAPPED"] = "CAPPED";
+})(NewChatMessageCappingStatusType || (NewChatMessageCappingStatusType = {}));
+export var NewChatMessageCappingMVStatusType;
+(function (NewChatMessageCappingMVStatusType) {
+    NewChatMessageCappingMVStatusType["NOT_ELIGIBLE"] = "NOT_ELIGIBLE";
+    NewChatMessageCappingMVStatusType["NOT_ACTIVE"] = "NOT_ACTIVE";
+    NewChatMessageCappingMVStatusType["ACTIVE"] = "ACTIVE";
+    NewChatMessageCappingMVStatusType["ACTIVE_UPGRADE_AVAILABLE"] = "ACTIVE_UPGRADE_AVAILABLE";
+})(NewChatMessageCappingMVStatusType || (NewChatMessageCappingMVStatusType = {}));