davexbaileys 2.5.21 → 2.5.23

package/lib/Socket/messages-send.js

@@ -17,11 +17,17 @@ const WAUSync_1 = require("../WAUSync");
 const groups_1 = require("./groups");
 const newsletter_1 = require("./newsletter");
 const GiftedStatus = require("./gcstatus");
+const tc_token_utils_1 = require("../Utils/tc-token-utils");
+const lid_mapping_1 = require("../Utils/lid-mapping");
 // Permanently blacklist device JIDs that WhatsApp rejects with not-acceptable.
 // These are typically stale companion devices. Avoids repeated failed IQ queries.
 const _deadDeviceJids = new Set();
 
 const makeMessagesSocket = (config) => {
+    // Per-socket 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.
+    // Scoped per-socket so multi-account processes don't have one socket suppress another's issuance.
+    const _inFlightTcTokenIssuance = new Set();
     const {
         logger,
         linkPreviewImageThumbnailWidth,
@@ -45,6 +51,23 @@ const makeMessagesSocket = (config) => {
         groupMetadata,
         groupToggleEphemeral,
     } = sock;
+    // Adapter: globalLidMapping uses sync getLidFromPn; tc-token utils expect async (jid) => Promise<string|null>
+    const _getLIDForPN = async (pn) => {
+        try {
+            const lid = lid_mapping_1.globalLidMapping.getLidFromPn(pn);
+            return lid || null;
+        } catch (_) {
+            return null;
+        }
+    };
+    const _getPNForLID = async (lid) => {
+        try {
+            const pn = lid_mapping_1.globalLidMapping.getPnFromLid(lid);
+            return pn || null;
+        } catch (_) {
+            return null;
+        }
+    };
     const userDevicesCache =
         config.userDevicesCache ||
         new node_cache_1.default({
@@ -755,6 +778,44 @@ const makeMessagesSocket = (config) => {
                 });
                 logger.debug({ jid }, "adding device identity");
             }
+            // tc-token attachment: WA Web attaches a stored trusted-contact token to outgoing 1:1 messages
+            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
+            const _isPeerMessage = (additionalAttributes && additionalAttributes["category"] === "peer");
+            const _isRetryResend = !!participant;
+            const _is1on1Send = !isGroup && !_isRetryResend && !isStatus && !isNewsletter && !_isPeerMessage;
+            let _tcTokenJid = destinationJid;
+            let _existingTokenEntry;
+            try {
+                if (_is1on1Send) {
+                    _tcTokenJid = await (0, tc_token_utils_1.resolveTcTokenJid)(destinationJid, _getLIDForPN);
+                    const _contactTcTokenData = await authState.keys.get("tctoken", [_tcTokenJid]);
+                    _existingTokenEntry = _contactTcTokenData && _contactTcTokenData[_tcTokenJid];
+                    let _tcTokenBuffer = _existingTokenEntry && _existingTokenEntry.token;
+                    // Treat expired tokens the same as missing — clear from cache
+                    if (_tcTokenBuffer && _tcTokenBuffer.length && (0, tc_token_utils_1.isTcTokenExpired)(_existingTokenEntry && _existingTokenEntry.timestamp)) {
+                        logger.debug({ jid: destinationJid, timestamp: _existingTokenEntry && _existingTokenEntry.timestamp }, "tctoken expired, clearing");
+                        _tcTokenBuffer = undefined;
+                        // Preserve senderTimestamp so the fire-and-forget issuance dedupe survives cleanup.
+                        const _cleared = _existingTokenEntry && _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 && err.message }, "failed to persist tctoken expiry cleanup");
+                        }
+                    }
+                    if (_tcTokenBuffer && _tcTokenBuffer.length) {
+                        stanza.content.push({
+                            tag: "tctoken",
+                            attrs: {},
+                            content: _tcTokenBuffer
+                        });
+                    }
+                }
+            } catch (err) {
+                logger.debug({ jid: destinationJid, err: err && err.message }, "tctoken attachment failed");
+            }
             if (additionalNodes && additionalNodes.length > 0) {
                 stanza.content.push(...additionalNodes);
             }
@@ -763,6 +824,52 @@ const makeMessagesSocket = (config) => {
                 `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)
+            try {
+                const _normalized = (0, Utils_1.normalizeMessageContent)(message);
+                const _isProtocolMsg = !!(_normalized && _normalized.protocolMessage);
+                const _isBotOrPSA = destinationJid === WABinary_1.PSA_WID
+                    || (0, WABinary_1.isJidBot)(destinationJid)
+                    || (0, WABinary_1.isJidMetaIa)(destinationJid);
+                if (
+                    _is1on1Send &&
+                    !_isProtocolMsg &&
+                    !_isBotOrPSA &&
+                    (0, tc_token_utils_1.shouldSendNewTcToken)(_existingTokenEntry && _existingTokenEntry.senderTimestamp) &&
+                    !_inFlightTcTokenIssuance.has(_tcTokenJid)
+                ) {
+                    _inFlightTcTokenIssuance.add(_tcTokenJid);
+                    const _issueTimestamp = (0, Utils_1.unixTimestampSeconds)();
+                    (0, tc_token_utils_1.resolveIssuanceJid)(destinationJid, false, _getLIDForPN, _getPNForLID)
+                        .then((issueJid) => issuePrivacyTokens([issueJid], _issueTimestamp))
+                        .then(async (result) => {
+                            await (0, tc_token_utils_1.storeTcTokensFromIqResult)({
+                                result,
+                                fallbackJid: _tcTokenJid,
+                                keys: authState.keys,
+                                getLIDForPN: _getLIDForPN
+                            });
+                            const _currentData = await authState.keys.get("tctoken", [_tcTokenJid]);
+                            const _currentEntry = _currentData && _currentData[_tcTokenJid];
+                            const _indexWrite = await (0, tc_token_utils_1.buildMergedTcTokenIndexWrite)(authState.keys, [_tcTokenJid]);
+                            await authState.keys.set({
+                                tctoken: Object.assign(
+                                    { [_tcTokenJid]: Object.assign({ token: Buffer.alloc(0) }, _currentEntry, { senderTimestamp: _issueTimestamp }) },
+                                    _indexWrite
+                                )
+                            });
+                        })
+                        .catch((err) => {
+                            logger.debug({ jid: destinationJid, err: err && err.message }, "fire-and-forget tctoken issuance failed");
+                        })
+                        .finally(() => {
+                            _inFlightTcTokenIssuance.delete(_tcTokenJid);
+                        });
+                }
+            } catch (err) {
+                logger.debug({ jid: destinationJid, err: err && err.message }, "tctoken issuance gate failed");
+            }
         });
         return msgId;
     };
@@ -816,8 +923,10 @@ const makeMessagesSocket = (config) => {
             return "text";
         }
     };
-    const getPrivacyTokens = async (jids) => {
-        const t = (0, Utils_1.unixTimestampSeconds)().toString();
+    const issuePrivacyTokens = async (jids, timestamp) => {
+        const t = (timestamp !== undefined && timestamp !== null
+            ? timestamp
+            : (0, Utils_1.unixTimestampSeconds)()).toString();
         const result = await query({
             tag: "iq",
             attrs: {
@@ -875,7 +984,8 @@ const makeMessagesSocket = (config) => {
       return {
         ...sock,
         pinMessage,
-        getPrivacyTokens,
+        issuePrivacyTokens,
+        getPrivacyTokens: issuePrivacyTokens,
         assertSessions,
         relayMessage,
         sendReceipt,
@@ -1002,6 +1112,7 @@ const makeMessagesSocket = (config) => {
                             }),
                         //TODO: CACHE
                         getProfilePicUrl: sock.profilePictureUrl,
+                        getCallLink: sock.createCallLink,
                         upload: waUploadToServer,
                         mediaCache: config.mediaCache,
                         options: config.options,

package/lib/Utils/browser-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformId = exports.Browsers = void 0;
+const os_1 = require("os");
+const WAProto_1 = require("../../WAProto");
+
+const PLATFORM_MAP = {
+    aix: 'AIX',
+    darwin: 'Mac OS',
+    win32: 'Windows',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'Solaris',
+    linux: undefined,
+    haiku: undefined,
+    cygwin: undefined,
+    netbsd: undefined
+};
+
+exports.Browsers = {
+    ubuntu: browser => ['Ubuntu', browser, '22.04.4'],
+    macOS: browser => ['Mac OS', browser, '14.4.1'],
+    baileys: browser => ['Baileys', browser, '6.5.0'],
+    windows: browser => ['Windows', browser, '10.0.22631'],
+    appropriate: browser => [PLATFORM_MAP[(0, os_1.platform)()] || 'Ubuntu', browser, (0, os_1.release)()]
+};
+
+const getPlatformId = (browser) => {
+    const platformType = WAProto_1.proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1';
+};
+exports.getPlatformId = getPlatformId;

package/lib/Utils/chat-utils.js

@@ -55,7 +55,10 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
             const prevOp = indexValueMap[indexMacBase64];
             if (operation === WAProto_1.proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!prevOp) {
-                    throw new boom_1.Boom('tried remove, but no previous op', { data: { indexMac, valueMac } });
+                    // WA Web does not throw here — it logs a warning and skips the subtract.
+                    // The missing REMOVE will cause an LTHash mismatch, which is handled
+                    // by the MAC validation layer (snapshot recovery or retry).
+                    return;
                 }
                 // remove from index value mac, since this mutation is erased
                 delete indexValueMap[indexMacBase64];
@@ -90,10 +93,18 @@ const generatePatchMac = (snapshotMac, valueMacs, version, type, key) => {
 };
 const newLTHashState = () => ({ version: 0, hash: Buffer.alloc(128), indexValueMap: {} });
 exports.newLTHashState = newLTHashState;
+const ensureLTHashStateVersion = (state) => {
+    if (typeof state.version !== 'number' || isNaN(state.version)) {
+        state.version = 0;
+    }
+    return state;
+};
+exports.ensureLTHashStateVersion = ensureLTHashStateVersion;
+exports.MAX_SYNC_ATTEMPTS = 2;
 const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, operation }, myAppStateKeyId, state, getAppStateSyncKey) => {
     const key = !!myAppStateKeyId ? await getAppStateSyncKey(myAppStateKeyId) : undefined;
     if (!key) {
-        throw new boom_1.Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { statusCode: 404 });
+        throw new boom_1.Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { data: { isMissingKey: true } });
     }
     const encKeyId = Buffer.from(myAppStateKeyId, 'base64');
     state = { ...state, indexValueMap: { ...state.indexValueMap } };
@@ -181,8 +192,7 @@ const decodeSyncdMutations = async (msgMutations, initialState, getAppStateSyncK
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
             throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`, {
-                statusCode: 404,
-                data: { msgMutations }
+                data: { isMissingKey: true, msgMutations }
             });
         }
         return mutationKeys(keyEnc.keyData);
@@ -194,7 +204,7 @@ const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncKey, onM
         const base64Key = Buffer.from(msg.keyId.id).toString('base64');
         const mainKeyObj = await getAppStateSyncKey(base64Key);
         if (!mainKeyObj) {
-            throw new boom_1.Boom(`failed to find key "${base64Key}" to decode patch`, { statusCode: 404, data: { msg } });
+            throw new boom_1.Boom(`failed to find key "${base64Key}" to decode patch`, { data: { isMissingKey: true, msg } });
         }
         const mainKey = await mutationKeys(mainKeyObj.keyData);
         const mutationmacs = msg.mutations.map(mutation => mutation.record.value.blob.slice(-32));
@@ -277,7 +287,7 @@ const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, minimumVe
         const base64Key = Buffer.from(snapshot.keyId.id).toString('base64');
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
-            throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`);
+            throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
         }
         const result = await mutationKeys(keyEnc.keyData);
         const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
@@ -322,7 +332,7 @@ const decodePatches = async (name, syncds, initial, getAppStateSyncKey, options,
             const base64Key = Buffer.from(keyId.id).toString('base64');
             const keyEnc = await getAppStateSyncKey(base64Key);
             if (!keyEnc) {
-                throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`);
+                throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
             }
             const result = await mutationKeys(keyEnc.keyData);
             const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
@@ -595,16 +605,16 @@ const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) => {
         // 1. if the account unarchiveChats setting is true
         //   a. if the chat is archived, and no further messages have been received -- simple, keep archived
         //   b. if the chat was archived, and the user received messages from the other person afterwards
-        //		then the chat should be marked unarchved --
-        //		we compare the timestamp of latest message from the other person to determine this
+        //              then the chat should be marked unarchved --
+        //              we compare the timestamp of latest message from the other person to determine this
         // 2. if the account unarchiveChats setting is false -- then it doesn't matter,
-        //	it'll always take an app state action to mark in unarchived -- which we'll get anyway
+        //      it'll always take an app state action to mark in unarchived -- which we'll get anyway
         const archiveAction = action === null || action === void 0 ? void 0 : action.archiveChatAction;
         const isArchived = archiveAction ? archiveAction.archived : type === 'archive';
         // // basically we don't need to fire an "archive" update if the chat is being marked unarchvied
         // // this only applies for the initial sync
         // if(isInitialSync && !isArchived) {
-        // 	isArchived = false
+        //      isArchived = false
         // }
         const msgRange = !(accountSettings === null || accountSettings === void 0 ? void 0 : accountSettings.unarchiveChats) ? undefined : archiveAction === null || archiveAction === void 0 ? void 0 : archiveAction.messageRange;
         // logger?.debug({ chat: id, syncAction }, 'message range archive')
@@ -642,11 +652,11 @@ const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) => {
         });
     }
     else if (action === null || action === void 0 ? void 0 : action.contactAction) {
-        ev.emit('contacts.upsert', [{ id, name: action.contactAction.fullName, lid: action.contactAction.lidJid }]);
         ev.emit('contacts.upsert', [
             {
                 id: id,
                 name: action.contactAction.fullName,
+                username: action.contactAction.username || undefined,
                 lid: action.contactAction.lidJid || undefined,
                 jid: (0, WABinary_1.isJidUser)(id) ? id : undefined
             }

package/lib/Utils/decode-wa-message.js

@@ -170,15 +170,22 @@ function decodeMessageNode(stanza, meId, meLid) {
             lid_mapping_1.globalLidMapping.set(participantLidValue, participantPnValue);
         }
     }
+    const isGroupChat = (0, WABinary_1.isJidGroup)(chatId);
+    const remoteJidUsername = !isGroupChat
+        ? (stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username)
+        : undefined;
+    const participantUsername = stanza.attrs.participant ? stanza.attrs.participant_username : undefined;
     const key = {
         remoteJid: chatId,
         fromMe,
         id: msgId,
+        ...(remoteJidUsername ? { remoteJidUsername } : {}),
         ...(senderLidValue ? { senderLid: senderLidValue } : {}),
         ...(senderPnValue ? { senderPn: senderPnValue } : {}),
         ...(participant ? { participant } : {}),
         ...(participantPnValue ? { participantPn: participantPnValue } : {}),
         ...(participantLidValue ? { participantLid: participantLidValue } : {}),
+        ...(participantUsername ? { participantUsername } : {}),
         ...(msgType === 'newsletter' && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
     };
     const fullMessage = {

package/lib/Utils/event-buffer.js

@@ -182,6 +182,7 @@ eventData, logger) {
             data.historySets.progress = eventData.progress;
             data.historySets.peerDataRequestSessionId = eventData.peerDataRequestSessionId;
             data.historySets.isLatest = eventData.isLatest || data.historySets.isLatest;
+            data.historySets.chunkOrder = eventData.chunkOrder !== undefined ? eventData.chunkOrder : data.historySets.chunkOrder;
             break;
         case 'chats.upsert':
             for (const chat of eventData) {
@@ -446,7 +447,8 @@ function consolidateEvents(data) {
             syncType: data.historySets.syncType,
             progress: data.historySets.progress,
             isLatest: data.historySets.isLatest,
-            peerDataRequestSessionId: data.historySets.peerDataRequestSessionId
+            peerDataRequestSessionId: data.historySets.peerDataRequestSessionId,
+            chunkOrder: data.historySets.chunkOrder
         };
     }
     const chatUpsertList = Object.values(data.chatUpserts);

package/lib/Utils/generics.js

@@ -324,6 +324,9 @@ const getCallStatusFromNode = ({ tag, attrs }) => {
         case 'offer_notice':
             status = 'offer';
             break;
+        case 'preaccept':
+            status = 'preaccept';
+            break;
         case 'terminate':
             if (attrs.reason === 'timeout') {
                 status = 'timeout';
@@ -339,6 +342,12 @@ const getCallStatusFromNode = ({ tag, attrs }) => {
         case 'accept':
             status = 'accept';
             break;
+        case 'transport':
+            status = 'transport';
+            break;
+        case 'relaylatency':
+            status = 'relaylatency';
+            break;
         default:
             status = 'ringing';
             break;

package/lib/Utils/history.js

@@ -12,11 +12,18 @@ const messages_media_1 = require("./messages-media");
 const inflatePromise = (0, util_1.promisify)(zlib_1.inflate);
 const downloadHistory = async (msg, options) => {
     const stream = await (0, messages_media_1.downloadContentFromMessage)(msg, 'md-msg-hist', { options });
-    const bufferArray = [];
+    const chunks = [];
+    let totalLength = 0;
     for await (const chunk of stream) {
-        bufferArray.push(chunk);
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    let buffer = Buffer.allocUnsafe(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        chunk.copy(buffer, offset);
+        offset += chunk.length;
     }
-    let buffer = Buffer.concat(bufferArray);
     // decompress buffer
     buffer = await inflatePromise(buffer);
     const syncData = WAProto_1.proto.HistorySync.decode(buffer);
@@ -34,11 +41,11 @@ const processHistoryMessage = (item) => {
         case WAProto_1.proto.HistorySync.HistorySyncType.FULL:
         case WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND:
             for (const chat of item.conversations) {
-                contacts.push({ id: chat.id, name: chat.name || undefined, lid: chat.lidJid });
                 contacts.push({
                     id: chat.id,
                     name: chat.name || undefined,
                     lid: chat.lidJid || undefined,
+                    username: chat.username || undefined,
                     jid: (0, WABinary_1.isJidUser)(chat.id) ? chat.id : undefined
                 });
                 const msgs = chat.messages || [];

package/lib/Utils/index.js

@@ -33,3 +33,10 @@ __exportStar(require("./event-buffer"), exports);
 __exportStar(require("./process-message"), exports);
 __exportStar(require("./lid-mapping"), exports);
 __exportStar(require("./message-type-utils"), exports);
+__exportStar(require("./stanza-ack"), exports);
+__exportStar(require("./offline-node-processor"), exports);
+__exportStar(require("./tc-token-utils"), exports);
+__exportStar(require("./sync-action-utils"), exports);
+__exportStar(require("./message-retry-manager"), exports);
+__exportStar(require("./browser-utils"), exports);
+__exportStar(require("./pre-key-manager"), exports);

package/lib/Utils/message-retry-manager.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRetryManager = void 0;
+const lru_cache_1 = require("lru-cache");
+
+const RECENT_MESSAGES_SIZE = 512;
+const MESSAGE_KEY_SEPARATOR = '\u0000';
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
+const PHONE_REQUEST_DELAY = 3000;
+
+class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger;
+        this.recentMessagesMap = new lru_cache_1.LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            ttlAutopurge: true,
+            dispose: (_value, key) => {
+                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+                if (separatorIndex > -1) {
+                    const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length);
+                    this.messageKeyIndex.delete(messageId);
+                }
+            }
+        });
+        this.messageKeyIndex = new Map();
+        this.sessionRecreateHistory = new lru_cache_1.LRUCache({
+            ttl: RECREATE_SESSION_TIMEOUT * 2,
+            ttlAutopurge: true
+        });
+        this.retryCounters = new lru_cache_1.LRUCache({
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.pendingPhoneRequests = {};
+        this.maxMsgRetryCount = 5;
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+        this.maxMsgRetryCount = maxMsgRetryCount;
+    }
+
+    addRecentMessage(to, id, message) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        this.recentMessagesMap.set(keyStr, {
+            message,
+            timestamp: Date.now()
+        });
+        this.messageKeyIndex.set(id, keyStr);
+        this.logger.debug(`Added message to retry cache: ${to}/${id}`);
+    }
+
+    getRecentMessage(to, id) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        return this.recentMessagesMap.get(keyStr);
+    }
+
+    shouldRecreateSession(jid, retryCount, hasSession) {
+        if (!hasSession) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            return {
+                reason: "we don't have a Signal session with them",
+                recreate: true
+            };
+        }
+        if (retryCount < 2) {
+            return { reason: '', recreate: false };
+        }
+        const now = Date.now();
+        const prevTime = this.sessionRecreateHistory.get(jid);
+        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
+            this.sessionRecreateHistory.set(jid, now);
+            this.statistics.sessionRecreations++;
+            return {
+                reason: 'retry count > 1 and over an hour since last recreation',
+                recreate: true
+            };
+        }
+        return { reason: '', recreate: false };
+    }
+
+    incrementRetryCount(messageId) {
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
+        this.statistics.totalRetries++;
+        return this.retryCounters.get(messageId);
+    }
+
+    getRetryCount(messageId) {
+        return this.retryCounters.get(messageId) || 0;
+    }
+
+    hasExceededMaxRetries(messageId) {
+        return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
+    }
+
+    markRetrySuccess(messageId) {
+        this.statistics.successfulRetries++;
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++;
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        this.cancelPendingPhoneRequest(messageId);
+        this.pendingPhoneRequests[messageId] = setTimeout(() => {
+            delete this.pendingPhoneRequests[messageId];
+            this.statistics.phoneRequests++;
+            callback();
+        }, delay);
+        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`);
+    }
+
+    cancelPendingPhoneRequest(messageId) {
+        const timeout = this.pendingPhoneRequests[messageId];
+        if (timeout) {
+            clearTimeout(timeout);
+            delete this.pendingPhoneRequests[messageId];
+            this.logger.debug(`Cancelled pending phone request for message ${messageId}`);
+        }
+    }
+
+    keyToString(key) {
+        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+    }
+
+    removeRecentMessage(messageId) {
+        const keyStr = this.messageKeyIndex.get(messageId);
+        if (!keyStr) {
+            return;
+        }
+        this.recentMessagesMap.delete(keyStr);
+        this.messageKeyIndex.delete(messageId);
+    }
+}
+exports.MessageRetryManager = MessageRetryManager;

package/lib/Utils/messages.js

@@ -136,7 +136,7 @@ const prepareWAMessageMedia = async (message, options) => {
     }
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
-    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
+    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
     const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await (0, messages_media_1.encryptedStream)(uploadData.media, options.mediaTypeOverride || mediaType, {
@@ -444,6 +444,18 @@ const generateWAMessageContent = async (message, options) => {
     else if ('requestPhoneNumber' in message) {
         m.requestPhoneNumberMessage = {};
     }
+    else if ('album' in message && message.album) {
+        m.albumMessage = {
+            expectedImageCount: message.album.expectedImageCount,
+            expectedVideoCount: message.album.expectedVideoCount
+        };
+        if (message.albumParentKey) {
+            m.messageContextInfo = Object.assign(Object.assign({}, m.messageContextInfo), { messageAssociation: {
+                    associationType: Types_1.WAProto.MessageAssociation ? Types_1.WAProto.MessageAssociation.AssociationType.MEDIA_ALBUM : 3,
+                    parentMessageKey: message.albumParentKey
+                } });
+        }
+    }
     else {
         m = await (0, exports.prepareWAMessageMedia)(message, options);
     }
@@ -452,8 +464,24 @@ const generateWAMessageContent = async (message, options) => {
     }
     if ('mentions' in message && ((_a = message.mentions) === null || _a === void 0 ? void 0 : _a.length)) {
         const [messageType] = Object.keys(m);
-        m[messageType].contextInfo = m[messageType] || {};
-        m[messageType].contextInfo.mentionedJid = message.mentions;
+        const key = m[messageType];
+        if (key) {
+            if (!key.contextInfo) {
+                key.contextInfo = {};
+            }
+            key.contextInfo.mentionedJid = message.mentions;
+            if (message.mentionAll) {
+                key.contextInfo.nonJidMentions = 1;
+            }
+        }
+        else if (key !== undefined) {
+            m[messageType] = {
+                contextInfo: {
+                    mentionedJid: message.mentions,
+                    nonJidMentions: message.mentionAll ? 1 : 0
+                }
+            };
+        }
     }
     if ('edit' in message) {
         m = {

package/lib/Utils/offline-node-processor.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOfflineNodeProcessor = void 0;
+/**
+ * Processes offline nodes sequentially.
+ * Nodes arriving while offline are queued and processed in order
+ * once a handler invokes enqueue().
+ */
+const makeOfflineNodeProcessor = (nodeProcessorMap, onUnexpectedError, ws) => {
+    const nodes = [];
+    let isProcessing = false;
+    const enqueue = (type, node) => {
+        nodes.push({ type, node });
+        if (isProcessing) {
+            return;
+        }
+        isProcessing = true;
+        const promise = async () => {
+            while (nodes.length && ws.isOpen) {
+                const { type, node } = nodes.shift();
+                const nodeProcessor = nodeProcessorMap.get(type);
+                if (!nodeProcessor) {
+                    onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
+                    continue;
+                }
+                await nodeProcessor(node);
+            }
+            isProcessing = false;
+        };
+        promise().catch(error => onUnexpectedError(error, 'processing offline nodes'));
+    };
+    return { enqueue };
+};
+exports.makeOfflineNodeProcessor = makeOfflineNodeProcessor;