@ryuu-reinzz/baileys 3.5.1 → 5.0.0

package/lib/Socket/messages-send.js

@@ -13,8 +13,10 @@ import {
 import {
     aggregateMessageKeysNotFromMe,
     assertMediaContent,
+    assertMeId,
     bindWaitForEvent,
     decryptMediaRetryData,
+    DEF_MEDIA_HOST,
     encodeNewsletterMessage,
     encodeSignedDeviceIdentity,
     encodeWAMessage,
@@ -36,29 +38,41 @@ import {
     downloadContentFromMessage,
     prepareWAMessageMedia,
     generateMessageID
-} from '@ryuu-reinzz/baileys';
+} from '../index.js';
 import {
     getUrlInfo
 } from '../Utils/link-preview.js';
 import {
-    makeKeyedMutex
+    makeKeyedMutex,
+    makeMutex
 } 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,
     isHostedLidUser,
     isHostedPnUser,
+    isJidBot,
     isJidGroup,
+    isJidMetaAI,
     isLidUser,
     isPnUser,
     jidDecode,
     jidEncode,
     jidNormalizedUser,
+    PSA_WID,
     S_WHATSAPP_NET
 } from '../WABinary/index.js';
 import {
@@ -100,22 +114,30 @@ export const makeMessagesSocket = (config) => {
         fetchPrivacySettings,
         sendNode,
         groupMetadata,
-        groupToggleEphemeral
+        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 ||
         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
     const encryptionMutex = 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) => {
         const media = await mediaConn;
         if (!media || forceGet || new Date().getTime() - media.fetchDate.getTime() > media.ttl * 1000) {
@@ -146,6 +168,9 @@ export const makeMessagesSocket = (config) => {
                     fetchDate: new Date()
                 };
                 logger.debug('fetched media conn');
+                if (node.hosts[0]) {
+                    mediaHost = node.hosts[0].hostname;
+                }
                 return node;
             })();
         }
@@ -340,18 +365,20 @@ 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) {
@@ -400,24 +427,15 @@ 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;
                 }
             }
@@ -458,11 +476,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;
     };
@@ -594,7 +607,7 @@ export const makeMessagesSocket = (config) => {
         useCachedGroupMetadata,
         statusJidList
     }) => {
-        const meId = authState.creds.me.id;
+        const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
         const isRetryResend = Boolean(participant?.jid);
         let shouldIncludeDeviceIdentity = isRetryResend;
@@ -889,14 +902,49 @@ 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
@@ -992,9 +1040,41 @@ export const makeMessagesSocket = (config) => {
                     }, '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',
@@ -1010,6 +1090,51 @@ export const makeMessagesSocket = (config) => {
                 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 = !!normalizeMessageContent(message)?.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);
@@ -1072,8 +1197,8 @@ export const makeMessagesSocket = (config) => {
         }
         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: {
@@ -1097,17 +1222,42 @@ export const makeMessagesSocket = (config) => {
         return result;
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
-    const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');    
-    sock.waUploadToServer = waUploadToServer;
-    sock.relayMessage = relayMessage;    
+    const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    Object.defineProperties(sock, {
+        waUploadToServer: {
+            value: waUploadToServer,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        },
+        relayMessage: {
+            value: relayMessage,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        }
+    });
+    registerSocketEndHandler(() => {
+        if (!config.userDevicesCache && userDevicesCache.close) {
+            userDevicesCache.close();
+        }
+        mediaConn = undefined;
+        if (messageRetryManager) {
+            messageRetryManager.clear();
+        }
+    });
     return {
         ...sock,
-        getPrivacyTokens,
+        userDevicesCache,
+        devicesMutex,
+        issuePrivacyTokens,
         assertSessions,
         sendReceipt,
         sendReceipts,
         readMessages,
         refreshMediaConn,
+        // Function (not getter) so the spread in chats.ts preserves the live closure binding.
+        getMediaHost: () => mediaHost,
         fetchPrivacySettings,
         sendPeerDataOperationMessage,
         createParticipantNodes,
@@ -1138,7 +1288,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
@@ -1163,92 +1313,92 @@ export const makeMessagesSocket = (config) => {
             return message;
         },
         sendMessage: async (jid, content, options = {}) => {
-        if (Array.isArray(content.buttons)) {
-                    return await sock.sendButton(jid, content, options);
-                } else {
-            const userJid = authState.creds.me.id;
-            if (typeof content === 'object' &&
-                'disappearingMessagesInChat' in content &&
-                typeof content['disappearingMessagesInChat'] !== 'undefined' &&
-                isJidGroup(jid)) {
-                const {
-                    disappearingMessagesInChat
-                } = content;
-                const value = typeof disappearingMessagesInChat === 'boolean' ?
-                    disappearingMessagesInChat ?
-                    WA_DEFAULT_EPHEMERAL :
-                    0 :
-                    disappearingMessagesInChat;
-                await groupToggleEphemeral(jid, value);
+            if (Array.isArray(content.buttons)) {
+                return await sock.sendButton(jid, content, options);
             } else {
-                const fullMsg = await generateWAMessage(jid, content, {
-                    logger,
-                    userJid,
-                    getUrlInfo: text => getUrlInfo(text, {
-                        thumbnailWidth: linkPreviewImageThumbnailWidth,
-                        fetchOpts: {
-                            timeout: 3000,
-                            ...(httpRequestOptions || {})
-                        },
+                const userJid = authState.creds.me.id;
+                if (typeof content === 'object' &&
+                    'disappearingMessagesInChat' in content &&
+                    typeof content['disappearingMessagesInChat'] !== 'undefined' &&
+                    isJidGroup(jid)) {
+                    const {
+                        disappearingMessagesInChat
+                    } = content;
+                    const value = typeof disappearingMessagesInChat === 'boolean' ?
+                        disappearingMessagesInChat ?
+                        WA_DEFAULT_EPHEMERAL :
+                        0 :
+                        disappearingMessagesInChat;
+                    await groupToggleEphemeral(jid, value);
+                } else {
+                    const fullMsg = await generateWAMessage(jid, content, {
                         logger,
-                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
-                    }),
-                    //TODO: CACHE
-                    getProfilePicUrl: sock.profilePictureUrl,
-                    getCallLink: sock.createCallLink,
-                    upload: waUploadToServer,
-                    mediaCache: config.mediaCache,
-                    options: config.options,
-                    messageId: generateMessageIDV2(sock.user?.id),
-                    ...options
-                });
-                const isEventMsg = 'event' in content && !!content.event;
-                const isDeleteMsg = 'delete' in content && !!content.delete;
-                const isEditMsg = 'edit' in content && !!content.edit;
-                const isPinMsg = 'pin' in content && !!content.pin;
-                const isPollMessage = 'poll' in content && !!content.poll;
-                const additionalAttributes = {};
-                const additionalNodes = [];
-                // required for delete
-                if (isDeleteMsg) {
-                    // if the chat is a group, and I am not the author, then delete the message as an admin
-                    if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
-                        additionalAttributes.edit = '8';
-                    } else {
-                        additionalAttributes.edit = '7';
-                    }
-                } else if (isEditMsg) {
-                    additionalAttributes.edit = '1';
-                } else if (isPinMsg) {
-                    additionalAttributes.edit = '2';
-                } else if (isPollMessage) {
-                    additionalNodes.push({
-                        tag: 'meta',
-                        attrs: {
-                            polltype: 'creation'
-                        }
+                        userJid,
+                        getUrlInfo: text => getUrlInfo(text, {
+                            thumbnailWidth: linkPreviewImageThumbnailWidth,
+                            fetchOpts: {
+                                timeout: 3000,
+                                ...(httpRequestOptions || {})
+                            },
+                            logger,
+                            uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+                        }),
+                        //TODO: CACHE
+                        getProfilePicUrl: sock.profilePictureUrl,
+                        getCallLink: sock.createCallLink,
+                        upload: waUploadToServer,
+                        mediaCache: config.mediaCache,
+                        options: config.options,
+                        messageId: generateMessageIDV2(sock.user?.id),
+                        ...options
                     });
-                } else if (isEventMsg) {
-                    additionalNodes.push({
-                        tag: 'meta',
-                        attrs: {
-                            event_type: 'creation'
+                    const isEventMsg = 'event' in content && !!content.event;
+                    const isDeleteMsg = 'delete' in content && !!content.delete;
+                    const isEditMsg = 'edit' in content && !!content.edit;
+                    const isPinMsg = 'pin' in content && !!content.pin;
+                    const isPollMessage = 'poll' in content && !!content.poll;
+                    const additionalAttributes = {};
+                    const additionalNodes = [];
+                    // required for delete
+                    if (isDeleteMsg) {
+                        // if the chat is a group, and I am not the author, then delete the message as an admin
+                        if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
+                            additionalAttributes.edit = '8';
+                        } else {
+                            additionalAttributes.edit = '7';
                         }
+                    } else if (isEditMsg) {
+                        additionalAttributes.edit = '1';
+                    } else if (isPinMsg) {
+                        additionalAttributes.edit = '2';
+                    } else if (isPollMessage) {
+                        additionalNodes.push({
+                            tag: 'meta',
+                            attrs: {
+                                polltype: 'creation'
+                            }
+                        });
+                    } else if (isEventMsg) {
+                        additionalNodes.push({
+                            tag: 'meta',
+                            attrs: {
+                                event_type: 'creation'
+                            }
+                        });
+                    }
+                    await relayMessage(jid, fullMsg.message, {
+                        messageId: fullMsg.key.id,
+                        useCachedGroupMetadata: options.useCachedGroupMetadata,
+                        additionalAttributes,
+                        statusJidList: options.statusJidList,
+                        additionalNodes
                     });
-                }
-                await relayMessage(jid, fullMsg.message, {
-                    messageId: fullMsg.key.id,
-                    useCachedGroupMetadata: options.useCachedGroupMetadata,
-                    additionalAttributes,
-                    statusJidList: options.statusJidList,
-                    additionalNodes
-                });
-                if (config.emitOwnEvents) {
-                    process.nextTick(async () => {
-                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
-                    });
-                }
-                return fullMsg;
+                    if (config.emitOwnEvents) {
+                        process.nextTick(async () => {
+                            await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                        });
+                    }
+                    return fullMsg;
                 }
             }
         }

package/lib/Socket/newsletter.js

@@ -79,10 +79,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);