@ryuu-reinzz/baileys 3.0.0-beta.2 → 3.0.0-beta.21

package/lib/Utils/event-buffer.js

@@ -28,6 +28,7 @@ export const makeEventBuffer = (logger) => {
     let data = makeBufferData();
     let isBuffering = false;
     let bufferTimeout = null;
+    let flushPendingTimeout = null; // Add a specific timer for the debounced flush to prevent leak
     let bufferCount = 0;
     const MAX_HISTORY_CACHE_SIZE = 10000; // Limit the history cache size to prevent memory bloat
     const BUFFER_TIMEOUT_MS = 30000; // 30 seconds
@@ -41,8 +42,7 @@ export const makeEventBuffer = (logger) => {
         if (!isBuffering) {
             logger.debug('Event buffer activated');
             isBuffering = true;
-            bufferCount++;
-            // Auto-flush after a timeout to prevent infinite buffering
+            bufferCount = 0;
             if (bufferTimeout) {
                 clearTimeout(bufferTimeout);
             }
@@ -53,9 +53,8 @@ export const makeEventBuffer = (logger) => {
                 }
             }, BUFFER_TIMEOUT_MS);
         }
-        else {
-            bufferCount++;
-        }
+        // Always increment count when requested
+        bufferCount++;
     }
     function flush() {
         if (!isBuffering) {
@@ -69,6 +68,10 @@ export const makeEventBuffer = (logger) => {
             clearTimeout(bufferTimeout);
             bufferTimeout = null;
         }
+        if (flushPendingTimeout) {
+            clearTimeout(flushPendingTimeout);
+            flushPendingTimeout = null;
+        }
         // Clear history cache if it exceeds the max size
         if (historyCache.size > MAX_HISTORY_CACHE_SIZE) {
             logger.debug({ cacheSize: historyCache.size }, 'Clearing history cache');
@@ -103,6 +106,27 @@ export const makeEventBuffer = (logger) => {
             };
         },
         emit(event, evData) {
+            // Check if this is a messages.upsert with a different type than what's buffered
+            // If so, flush the buffered messages first to avoid type overshadowing
+            if (event === 'messages.upsert') {
+                const { type } = evData;
+                const existingUpserts = Object.values(data.messageUpserts);
+                if (existingUpserts.length > 0) {
+                    const bufferedType = existingUpserts[0].type;
+                    if (bufferedType !== type) {
+                        logger.debug({ bufferedType, newType: type }, 'messages.upsert type mismatch, emitting buffered messages');
+                        // Emit the buffered messages with their correct type
+                        ev.emit('event', {
+                            'messages.upsert': {
+                                messages: existingUpserts.map(m => m.message),
+                                type: bufferedType
+                            }
+                        });
+                        // Clear the message upserts from the buffer
+                        data.messageUpserts = {};
+                    }
+                }
+            }
             if (isBuffering && BUFFERABLE_EVENT_SET.has(event)) {
                 append(data, historyCache, event, evData, logger);
                 return true;
@@ -135,8 +159,10 @@ export const makeEventBuffer = (logger) => {
                 finally {
                     bufferCount = Math.max(0, bufferCount - 1);
                     if (bufferCount === 0) {
-                        // Auto-flush when no other buffers are active
-                        setTimeout(flush, 100);
+                        // Only schedule ONE timeout, not 10,000
+                        if (!flushPendingTimeout) {
+                            flushPendingTimeout = setTimeout(flush, 100);
+                        }
                     }
                 }
             };

package/lib/Utils/generics.js

@@ -1,7 +1,7 @@
 import { Boom } from '@hapi/boom';
 import { createHash, randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
-const baileysVersion = [2, 3000, 1027934701];
+const baileysVersion = [2, 3000, 1033105955];
 import { DisconnectReason } from '../Types/index.js';
 import { getAllBinaryNodeChildren, jidDecode } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
@@ -31,6 +31,9 @@ export const BufferJSON = {
     }
 };
 export const getKeyAuthor = (key, meId = 'me') => (key?.fromMe ? meId : key?.participantAlt || key?.remoteJidAlt || key?.participant || key?.remoteJid) || '';
+export const isStringNullOrEmpty = (value) => 
+// eslint-disable-next-line eqeqeq
+value == null || value === '';
 export const writeRandomPadMax16 = (msg) => {
     const pad = randomBytes(1);
     const padLength = (pad[0] & 0x0f) + 1;

package/lib/Utils/history.js

@@ -2,10 +2,26 @@ import { promisify } from 'util';
 import { inflate } from 'zlib';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
 import { toNumber } from './generics.js';
 import { normalizeMessageContent } from './messages.js';
 import { downloadContentFromMessage } from './messages-media.js';
 const inflatePromise = promisify(inflate);
+const extractPnFromMessages = (messages) => {
+    for (const msgItem of messages) {
+        const message = msgItem.message;
+        // Only extract from outgoing messages (fromMe: true) in 1:1 chats
+        // because userReceipt.userJid is the recipient's JID
+        if (!message?.key?.fromMe || !message.userReceipt?.length) {
+            continue;
+        }
+        const userJid = message.userReceipt[0]?.userJid;
+        if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
+            return userJid;
+        }
+    }
+    return undefined;
+};
 export const downloadHistory = async (msg, options) => {
     const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
     const bufferArray = [];
@@ -18,10 +34,18 @@ export const downloadHistory = async (msg, options) => {
     const syncData = proto.HistorySync.decode(buffer);
     return syncData;
 };
-export const processHistoryMessage = (item) => {
+export const processHistoryMessage = (item, logger) => {
     const messages = [];
     const contacts = [];
     const chats = [];
+    const lidPnMappings = [];
+    logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
+    // Extract LID-PN mappings for all sync types
+    for (const m of item.phoneNumberToLidMappings || []) {
+        if (m.lidJid && m.pnJid) {
+            lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
+        }
+    }
     switch (item.syncType) {
         case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
         case proto.HistorySync.HistorySyncType.RECENT:
@@ -30,10 +54,26 @@ export const processHistoryMessage = (item) => {
             for (const chat of item.conversations) {
                 contacts.push({
                     id: chat.id,
-                    name: chat.name || undefined,
-                    lid: chat.lidJid || undefined,
+                    name: chat.displayName || chat.name || chat.username || undefined,
+                    lid: chat.lidJid || chat.accountLid || undefined,
                     phoneNumber: chat.pnJid || undefined
                 });
+                const chatId = chat.id;
+                const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
+                const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
+                if (isLid && chat.pnJid) {
+                    lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
+                }
+                else if (isPn && chat.lidJid) {
+                    lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
+                }
+                else if (isLid && !chat.pnJid) {
+                    // Fallback: extract PN from userReceipt in messages when pnJid is missing
+                    const pnFromReceipt = extractPnFromMessages(chat.messages || []);
+                    if (pnFromReceipt) {
+                        lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
+                    }
+                }
                 const msgs = chat.messages || [];
                 delete chat.messages;
                 for (const item of msgs) {
@@ -68,11 +108,12 @@ export const processHistoryMessage = (item) => {
         chats,
         contacts,
         messages,
+        lidPnMappings,
         syncType: item.syncType,
         progress: item.progress
     };
 };
-export const downloadAndProcessHistorySyncNotification = async (msg, options) => {
+export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
     let historyMsg;
     if (msg.initialHistBootstrapInlinePayload) {
         historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
@@ -80,7 +121,7 @@ export const downloadAndProcessHistorySyncNotification = async (msg, options) =>
     else {
         historyMsg = await downloadHistory(msg, options);
     }
-    return processHistoryMessage(historyMsg);
+    return processHistoryMessage(historyMsg, logger);
 };
 export const getHistoryMsg = (message) => {
     const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,49 @@
+import NodeCache from '@cacheable/node-cache';
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
+import { isStringNullOrEmpty } from './generics.js';
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = getBinaryNodeChild(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = jidDecode(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}
+//# sourceMappingURL=identity-change-handler.js.map

package/lib/Utils/index.js

@@ -16,4 +16,6 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
+export * from './identity-change-handler.js';
+export * from './use-sqlite-auth-state.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/lt-hash.js

@@ -1,48 +1,8 @@
-import { hkdf } from './crypto.js';
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
 /**
  * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
  * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
  * if the same series of mutations was made sequentially.
  */
-const o = 128;
-class LTHash {
-    constructor(e) {
-        this.salt = e;
-    }
-    async add(e, t) {
-        for (const item of t) {
-            e = await this._addSingle(e, item);
-        }
-        return e;
-    }
-    async subtract(e, t) {
-        for (const item of t) {
-            e = await this._subtractSingle(e, item);
-        }
-        return e;
-    }
-    async subtractThenAdd(e, addList, subtractList) {
-        const subtracted = await this.subtract(e, subtractList);
-        return this.add(subtracted, addList);
-    }
-    async _addSingle(e, t) {
-        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
-    }
-    async _subtractSingle(e, t) {
-        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
-    }
-    performPointwiseWithOverflow(e, t, op) {
-        const n = new DataView(e);
-        const i = new DataView(t);
-        const out = new ArrayBuffer(n.byteLength);
-        const s = new DataView(out);
-        for (let offset = 0; offset < n.byteLength; offset += 2) {
-            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
-        }
-        return out;
-    }
-}
-export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
 //# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.js

@@ -1,39 +1,32 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
 export const makeMutex = () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let task = Promise.resolve();
-    let taskTimeout;
+    const mutex = new AsyncMutex();
     return {
         mutex(code) {
-            task = (async () => {
-                // wait for the previous task to complete
-                // if there is an error, we swallow so as to not block the queue
-                try {
-                    await task;
-                }
-                catch { }
-                try {
-                    // execute the current task
-                    const result = await code();
-                    return result;
-                }
-                finally {
-                    clearTimeout(taskTimeout);
-                }
-            })();
-            // we replace the existing task, appending the new piece of execution to it
-            // so the next task will have to wait for this one to finish
-            return task;
+            return mutex.runExclusive(code);
         }
     };
 };
 export const makeKeyedMutex = () => {
-    const map = {};
+    const map = new Map();
     return {
-        mutex(key, task) {
-            if (!map[key]) {
-                map[key] = makeMutex();
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
             }
-            return map[key].mutex(task);
         }
     };
 };

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

@@ -5,6 +5,28 @@ const MESSAGE_KEY_SEPARATOR = '\u0000';
 /** Timeout for session recreation - 1 hour */
 const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
 const PHONE_REQUEST_DELAY = 3000;
+// Retry reason codes matching WhatsApp Web's Signal error codes.
+export var RetryReason;
+(function (RetryReason) {
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+    /** MAC verification failed - most common cause of decryption failures */
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+    /** Explicit MAC failure - session is definitely out of sync */
+    RetryReason[RetryReason["SignalErrorBadMac"] = 7] = "SignalErrorBadMac";
+    RetryReason[RetryReason["SignalErrorInvalidSession"] = 8] = "SignalErrorInvalidSession";
+    RetryReason[RetryReason["SignalErrorInvalidMsgKey"] = 9] = "SignalErrorInvalidMsgKey";
+    RetryReason[RetryReason["BadBroadcastEphemeralSetting"] = 10] = "BadBroadcastEphemeralSetting";
+    RetryReason[RetryReason["UnknownCompanionNoPrekey"] = 11] = "UnknownCompanionNoPrekey";
+    RetryReason[RetryReason["AdvFailure"] = 12] = "AdvFailure";
+    RetryReason[RetryReason["StatusRevokeDelay"] = 13] = "StatusRevokeDelay";
+})(RetryReason || (RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */
+const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
 export class MessageRetryManager {
     constructor(logger, maxMsgRetryCount) {
         this.logger = logger;
@@ -65,9 +87,10 @@ export class MessageRetryManager {
         return this.recentMessagesMap.get(keyStr);
     }
     /**
-     * Check if a session should be recreated based on retry count and history
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
      */
-    shouldRecreateSession(jid, retryCount, hasSession) {
+    shouldRecreateSession(jid, hasSession, errorCode) {
         // If we don't have a session, always recreate
         if (!hasSession) {
             this.sessionRecreateHistory.set(jid, Date.now());
@@ -77,9 +100,15 @@ export class MessageRetryManager {
                 recreate: true
             };
         }
-        // Only consider recreation if retry count > 1
-        if (retryCount < 2) {
-            return { reason: '', recreate: false };
+        // IMMEDIATE recreation for MAC errors - session is definitely out of sync
+        if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            this.logger.warn({ jid, errorCode: RetryReason[errorCode] }, 'MAC error detected, forcing immediate session recreation');
+            return {
+                reason: `MAC error (code ${errorCode}: ${RetryReason[errorCode]}), immediate session recreation`,
+                recreate: true
+            };
         }
         const now = Date.now();
         const prevTime = this.sessionRecreateHistory.get(jid);
@@ -94,6 +123,30 @@ export class MessageRetryManager {
         }
         return { reason: '', recreate: false };
     }
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr) {
+        if (errorAttr === undefined || errorAttr === '') {
+            return undefined;
+        }
+        const code = parseInt(errorAttr, 10);
+        if (Number.isNaN(code)) {
+            return undefined;
+        }
+        // Validate it's a known RetryReason
+        if (code >= RetryReason.UnknownError && code <= RetryReason.StatusRevokeDelay) {
+            return code;
+        }
+        return RetryReason.UnknownError;
+    }
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode) {
+        return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
+    }
     /**
      * Increment retry counter for a message
      */