@crysnovax/baileys 2.5.6 → 2.6.1

package/lib/Types/index.js

@@ -3,13 +3,13 @@ export * from './GroupMetadata.js';
 export * from './Chat.js';
 export * from './Contact.js';
 export * from './State.js';
+export * from './Mex.js';
 export * from './Message.js';
 export * from './Socket.js';
 export * from './Events.js';
 export * from './Product.js';
 export * from './Call.js';
 export * from './Signal.js';
-export * from './Newsletter.js';
 export var DisconnectReason;
 (function (DisconnectReason) {
     DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";

package/lib/Utils/auth-utils.js

@@ -1,4 +1,5 @@
 import NodeCache from '@cacheable/node-cache';
+import { Boom } from '@hapi/boom';
 import { AsyncLocalStorage } from 'async_hooks';
 import { Mutex } from 'async-mutex';
 import { randomBytes } from 'crypto';
@@ -264,6 +265,17 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
         }
     };
 };
+/**
+ * Returns the authenticated user's JID, or throws a Boom-401 if creds are not yet authenticated.
+ * Use this anywhere we'd otherwise reach for `creds.me!.id` to fail fast with a descriptive error.
+ */
+export const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
+};
 export const initAuthCreds = () => {
     const identityKey = Curve.generateKeyPair();
     return {
@@ -286,4 +298,4 @@ export const initAuthCreds = () => {
         routingInfo: undefined,
         additionalData: undefined
     };
-};
+};

package/lib/Utils/chat-utils.js

@@ -38,7 +38,7 @@ const to64BitNetworkOrder = (e) => {
     buff.writeUint32BE(e, 4);
     return buff;
 };
-const makeLtHashGenerator = ({ indexValueMap, hash }) => {
+export const makeLtHashGenerator = ({ indexValueMap, hash }) => {
     indexValueMap = { ...indexValueMap };
     const addBuffs = [];
     const subBuffs = [];
@@ -48,7 +48,10 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
             const prevOp = indexValueMap[indexMacBase64];
             if (operation === proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!prevOp) {
-                    throw new 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];
@@ -80,10 +83,33 @@ const generatePatchMac = (snapshotMac, valueMacs, version, type, key) => {
     return hmacSign(total, key);
 };
 export const newLTHashState = () => ({ version: 0, hash: Buffer.alloc(128), indexValueMap: {} });
+export const ensureLTHashStateVersion = (state) => {
+    if (typeof state.version !== 'number' || isNaN(state.version)) {
+        state.version = 0;
+    }
+    return state;
+};
+export const MAX_SYNC_ATTEMPTS = 2;
+/**
+ * Check if an error is a missing app state sync key.
+ * WA Web treats these as "Blocked" (waits for key arrival), not fatal.
+ * In Baileys we retry with a snapshot which may use a different key.
+ */
+export const isMissingKeyError = (error) => {
+    return error?.data?.isMissingKey === true;
+};
+/**
+ * Determines if an app state sync error is unrecoverable.
+ * TypeError indicates a WASM crash; otherwise we give up after MAX_SYNC_ATTEMPTS.
+ * Missing keys are NOT checked here — they are handled separately as "Blocked".
+ */
+export const isAppStateSyncIrrecoverable = (error, attempts) => {
+    return attempts >= MAX_SYNC_ATTEMPTS || error?.name === 'TypeError';
+};
 export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, operation }, myAppStateKeyId, state, getAppStateSyncKey) => {
     const key = !!myAppStateKeyId ? await getAppStateSyncKey(myAppStateKeyId) : undefined;
     if (!key) {
-        throw new Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { statusCode: 404 });
+        throw new Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { data: { isMissingKey: true } });
     }
     const encKeyId = Buffer.from(myAppStateKeyId, 'base64');
     state = { ...state, indexValueMap: { ...state.indexValueMap } };
@@ -139,17 +165,36 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         // otherwise, if it's only a record -- it'll be a SET mutation
         const operation = 'operation' in msgMutation ? msgMutation.operation : proto.SyncdMutation.SyncdOperation.SET;
         const record = 'record' in msgMutation && !!msgMutation.record ? msgMutation.record : msgMutation;
-        const key = await getKey(record.keyId.id);
+        let key;
+        try {
+            key = await getKey(record.keyId.id);
+        }
+        catch (err) {
+            // Missing-key errors must propagate so the orchestrator can park the
+            // collection (Blocked) and retry when APP_STATE_SYNC_KEY_SHARE arrives.
+            // Other errors → individual record corruption, skip and keep going.
+            if (isMissingKeyError(err))
+                throw err;
+            continue;
+        }
         const content = record.value.blob;
         const encContent = content.subarray(0, -32);
         const ogValueMac = content.subarray(-32);
         if (validateMacs) {
             const contentHmac = generateMac(operation, encContent, record.keyId.id, key.valueMacKey);
             if (Buffer.compare(contentHmac, ogValueMac) !== 0) {
-                throw new Boom('HMAC content verification failed');
+                // HMAC verification failed — skip this record
+                continue;
             }
         }
-        const result = aesDecrypt(encContent, key.valueEncryptionKey);
+        let result;
+        try {
+            result = aesDecrypt(encContent, key.valueEncryptionKey);
+        }
+        catch {
+            // decrypt failed — skip this record instead of aborting
+            continue;
+        }
         const syncAction = proto.SyncActionData.decode(result);
         if (validateMacs) {
             const hmac = hmacSign(syncAction.index, key.indexKey);
@@ -175,8 +220,7 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
             throw new Boom(`failed to find key "${base64Key}" to decode mutation`, {
-                statusCode: 404,
-                data: { msgMutations }
+                data: { isMissingKey: true, msgMutations }
             });
         }
         const keys = mutationKeys(keyEnc.keyData);
@@ -189,7 +233,7 @@ export const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncK
         const base64Key = Buffer.from(msg.keyId.id).toString('base64');
         const mainKeyObj = await getAppStateSyncKey(base64Key);
         if (!mainKeyObj) {
-            throw new Boom(`failed to find key "${base64Key}" to decode patch`, { statusCode: 404, data: { msg } });
+            throw new Boom(`failed to find key "${base64Key}" to decode patch`, { data: { isMissingKey: true, msg } });
         }
         const mainKey = mutationKeys(mainKeyObj.keyData);
         const mutationmacs = msg.mutations.map(mutation => mutation.record.value.blob.slice(-32));
@@ -250,7 +294,7 @@ export const downloadExternalPatch = async (blob, options) => {
     const syncData = proto.SyncdMutations.decode(buffer);
     return syncData;
 };
-export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, minimumVersionNumber, validateMacs = true) => {
+export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, minimumVersionNumber, validateMacs = true, logger) => {
     const newState = newLTHashState();
     newState.version = toNumber(snapshot.version.version);
     const mutationMap = {};
@@ -267,12 +311,17 @@ export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, mi
         const base64Key = Buffer.from(snapshot.keyId.id).toString('base64');
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
-            throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
+            throw new Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
         }
         const result = mutationKeys(keyEnc.keyData);
         const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
         if (Buffer.compare(snapshot.mac, computedSnapshotMac) !== 0) {
-            throw new Boom(`failed to verify LTHash at ${newState.version} of ${name} from snapshot`);
+            // LTHash verification may fail when decodeSyncdMutations skipped undecryptable
+            // records (poisoned server-side snapshot); the aggregate client hash diverges
+            // from the server-computed mac. Fall through with a warning so the session stays
+            // alive with partial state, symmetric to how decodePatches handles its own
+            // LTHash mismatch a few lines below.
+            logger?.warn({ name, version: newState.version }, 'LTHash verification failed on snapshot, continuing with partial state');
         }
     }
     return {
@@ -297,24 +346,34 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         const patchVersion = toNumber(version.version);
         newState.version = patchVersion;
         const shouldMutate = typeof minimumVersionNumber === 'undefined' || patchVersion > minimumVersionNumber;
-        const decodeResult = await decodeSyncdPatch(syncd, name, newState, getAppStateSyncKey, shouldMutate
-            ? mutation => {
-                const index = mutation.syncAction.index?.toString();
-                mutationMap[index] = mutation;
-            }
-            : () => { }, true);
+        let decodeResult;
+        try {
+            decodeResult = await decodeSyncdPatch(syncd, name, newState, getAppStateSyncKey, shouldMutate
+                ? mutation => {
+                    const index = mutation.syncAction.index?.toString();
+                    mutationMap[index] = mutation;
+                }
+                : () => { }, validateMacs);
+        }
+        catch (err) {
+            if (isMissingKeyError(err))
+                throw err;
+            logger?.warn({ name, version: patchVersion, error: err.message }, 'failed to decode patch, skipping');
+            continue;
+        }
         newState.hash = decodeResult.hash;
         newState.indexValueMap = decodeResult.indexValueMap;
         if (validateMacs) {
             const base64Key = Buffer.from(keyId.id).toString('base64');
             const keyEnc = await getAppStateSyncKey(base64Key);
             if (!keyEnc) {
-                throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
+                throw new Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
             }
             const result = mutationKeys(keyEnc.keyData);
             const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
             if (Buffer.compare(snapshotMac, computedSnapshotMac) !== 0) {
-                throw new Boom(`failed to verify LTHash at ${newState.version} of ${name}`);
+                logger?.warn({ name, version: newState.version }, 'LTHash verification failed, skipping remaining patches');
+                break;
             }
         }
         // clear memory used up by the mutations
@@ -779,6 +838,7 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
                     action.lidContactAction.firstName ||
                     action.lidContactAction.username ||
                     undefined,
+                username: action.lidContactAction.username || undefined,
                 lid: id,
                 phoneNumber: undefined
             }
@@ -808,4 +868,4 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
         const chatLastMsgTimestamp = Number(chat?.lastMessageRecvTimestamp || 0);
         return lastMsgTimestamp >= chatLastMsgTimestamp;
     }
-};
+};

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

@@ -27,13 +27,16 @@ const storeMappingFromEnvelope = async (stanza, sender, repository, decryptionJi
 };
 export const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node';
 export const MISSING_KEYS_ERROR_TEXT = 'Key used already or never filled';
+export const ACCOUNT_RESTRICTED_TEXT = 'Your account has been restricted';
 // Retry configuration for failed decryption
 export const DECRYPTION_RETRY_CONFIG = {
     maxRetries: 3,
     baseDelayMs: 100,
     sessionRecordErrors: ['No session record', 'SessionError: No session record']
 };
+/** NACK reason codes we send to the server (client → server) */
 export const NACK_REASONS = {
+    SenderReachoutTimelocked: 463,
     ParsingError: 487,
     UnrecognizedStanza: 488,
     UnrecognizedStanzaClass: 489,
@@ -48,6 +51,21 @@ export const NACK_REASONS = {
     UnsupportedLIDGroup: 551,
     DBOperationFailed: 552
 };
+/**
+ * Server-side error codes returned in ack stanzas (server → client) that we
+ * currently have dedicated handlers for. Extend as more handlers are added.
+ * Distinct from the client-side NackReason enum (WAWebCreateNackFromStanza).
+ */
+export const SERVER_ERROR_CODES = {
+    /**
+     * 1:1 message missing privacy token (tctoken). Usually means the account is
+     * restricted: WhatsApp blocks starting new chats but preserves existing ones,
+     * since established chats already carry a tctoken.
+     */
+    MessageAccountRestriction: '463',
+    /** Stanza validation failure (SMAX_INVALID) — likely stale device session */
+    SmaxInvalid: '479'
+};
 export const extractAddressingContext = (stanza) => {
     let senderAlt;
     let recipientAlt;
@@ -88,6 +106,12 @@ export function decodeMessageNode(stanza, meId, meLid) {
     const from = stanza.attrs.from;
     const participant = stanza.attrs.participant;
     const recipient = stanza.attrs.recipient;
+    if (!msgId) {
+        throw new Boom('Invalid message stanza: missing id attribute', { data: stanza });
+    }
+    if (!from) {
+        throw new Boom('Invalid message stanza: missing from attribute', { data: stanza });
+    }
     const addressingContext = extractAddressingContext(stanza);
     const isMe = (jid) => areJidsSameUser(jid, meId);
     const isMeLid = (jid) => areJidsSameUser(jid, meLid);
@@ -102,6 +126,12 @@ export function decodeMessageNode(stanza, meId, meLid) {
             chatId = recipient;
         }
         else {
+            // Peer-routed self stanzas (history sync, app-state sync, etc.) arrive
+            // with `from` set to our own device but no `recipient` attribute —
+            // still mark as fromMe so self-only protocolMessage handlers run.
+            if (isMe(from) || isMeLid(from)) {
+                fromMe = true;
+            }
             chatId = from;
         }
         msgType = 'chat';
@@ -148,10 +178,14 @@ export function decodeMessageNode(stanza, meId, meLid) {
     const key = {
         remoteJid: chatId,
         remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        remoteJidUsername: !isJidGroup(chatId)
+            ? stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username
+            : undefined,
         fromMe,
         id: msgId,
         participant,
         participantAlt: isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        participantUsername: stanza.attrs.participant ? stanza.attrs.participant_username : undefined,
         addressingMode: addressingContext.addressingMode,
         ...(msgType === 'newsletter' && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
     };
@@ -279,4 +313,4 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
 function isSessionRecordError(error) {
     const errorMessage = error?.message || error?.toString() || '';
     return DECRYPTION_RETRY_CONFIG.sessionRecordErrors.some(errorPattern => errorMessage.includes(errorPattern));
-}
+}

package/lib/Utils/index.js

@@ -16,6 +16,7 @@ export * from './lt-hash.js';
 export * from './auth-utils.js';
 export * from './use-multi-file-auth-state.js';
 export * from './use-single-file-auth-state.js';
+export * from './use-sqlite-auth-state.js';
 export * from './link-preview.js';
 export * from './event-buffer.js';
 export * from './process-message.js';

package/lib/Utils/messages-media.js

@@ -120,10 +120,8 @@ export const extractVideoThumb = async (path, time, size) => {
     ffmpeg.stderr.on('data', (chunk) => stderrChunks.push(chunk));
     const [code] = await once(ffmpeg, 'close');
     if (code !== 0) {
-        throw new Boom(
-            `FFmpeg failed (code ${code}):\n` +
-            Buffer.concat(stderrChunks).toString('utf8')
-        );
+        throw new Boom(`FFmpeg failed (code ${code}):\n` +
+            Buffer.concat(stderrChunks).toString('utf8'));
     }
     return buffer;
 };
@@ -323,7 +321,7 @@ export async function generateThumbnail(file, mediaType, options) {
     let originalImageDimensions;
     if (mediaType === 'image') {
         const { buffer, original } = await extractImageThumb(file);
-        thumbnail = buffer;
+        thumbnail = buffer.toString('base64');
         if (original.width && original.height) {
             originalImageDimensions = {
                 width: original.width,
@@ -333,8 +331,8 @@ export async function generateThumbnail(file, mediaType, options) {
     }
     else if (mediaType === 'video') {
         try {
-            const buffer = await extractVideoThumb(file, '00:00:00', { width: 32, height: 32 });
-            thumbnail = buffer;
+            const buff = await extractVideoThumb(file, '00:00:00', { width: 32, height: 32 });
+            thumbnail = buff.toString('base64');
         }
         catch (err) {
             options.logger?.debug('could not generate video thumb: ' + err);
@@ -448,15 +446,27 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
         throw error;
     }
 };
-const DEF_HOST = 'mmg.whatsapp.net';
+export const DEF_MEDIA_HOST = 'mmg.whatsapp.net';
 const AES_CHUNK_SIZE = 16;
 const toSmallestChunkSize = (num) => {
     return Math.floor(num / AES_CHUNK_SIZE) * AES_CHUNK_SIZE;
 };
-export const getUrlFromDirectPath = (directPath) => `https://${DEF_HOST}${directPath}`;
+export const getUrlFromDirectPath = (directPath, host = DEF_MEDIA_HOST) => `https://${host}${directPath}`;
+const extractHost = (url) => {
+    if (!url)
+        return undefined;
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return undefined;
+    }
+};
 export const downloadContentFromMessage = async ({ mediaKey, directPath, url }, type, opts = {}) => {
-    const isValidMediaUrl = url?.startsWith('https://mmg.whatsapp.net/');
-    const downloadUrl = isValidMediaUrl ? url : getUrlFromDirectPath(directPath);
+    // Fallback host: explicit opt > host parsed from `url` > DEF_MEDIA_HOST.
+    // Lets us honor a non-default host carried by the proto without forcing callers to thread it through.
+    const fallbackHost = opts.host ?? extractHost(url);
+    const downloadUrl = directPath ? getUrlFromDirectPath(directPath, fallbackHost) : url;
     if (!downloadUrl) {
         throw new Boom('No valid media URL or directPath present in message', { statusCode: 400 });
     }
@@ -516,7 +526,7 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
     };
     const output = new Transform({
         transform(chunk, _, callback) {
-            let data = Buffer.concat([remainingBytes, chunk]);
+            let data = remainingBytes.length ? Buffer.concat([remainingBytes, chunk]) : chunk;
             const decryptLength = toSmallestChunkSize(data.length);
             remainingBytes = data.slice(decryptLength);
             data = data.slice(0, decryptLength);
@@ -635,8 +645,10 @@ const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) =>
     // Convert Node.js Readable to Web ReadableStream
     const nodeStream = createReadStream(filePath);
     const webStream = Readable.toWeb(nodeStream);
+    // Native fetch only accepts Undici-style dispatchers, not generic https Agents.
+    const dispatcher = typeof agent?.dispatch === 'function' ? agent : undefined;
     const response = await fetch(url, {
-        dispatcher: agent,
+        ...(dispatcher ? { dispatcher } : {}),
         method: 'POST',
         body: webStream,
         headers,
@@ -700,9 +712,9 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
             logger.debug(`uploading to "${hostname}"`);
             const auth = encodeURIComponent(uploadInfo.auth);
             // Lia@Changes 06-02-26 --- Switch media path map for newsletter uploads
-            const mediaPathMap = newsletter ? NEWSLETTER_MEDIA_PATH_MAP : MEDIA_PATH_MAP
+            const mediaPathMap = newsletter ? NEWSLETTER_MEDIA_PATH_MAP : MEDIA_PATH_MAP;
             // Lia@Changes 20-03-26 --- Add server thumb for newsletter media
-            const serverThumb = newsletter ? '&server_thumb_gen=1' : ''
+            const serverThumb = newsletter ? '&server_thumb_gen=1' : '';
             const url = `https://${hostname}${mediaPathMap[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}${serverThumb}`;
             let result;
             try {
@@ -827,4 +839,4 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.DECRYPTION_ERROR]: 412,
     [proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
-};
+};