@fer2809fl/baileys 7.0.2 → 7.0.4

package/lib/Socket/groups.js

@@ -1,11 +1,13 @@
+import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
 import { makeChatsSocket } from './chats.js';
+const GROUP_METADATA_CACHE_TTL_MS = 30_000;
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
-    const { authState, ev, query, upsertMessage } = sock;
+    const { authState, ev, query, upsertMessage, signalRepository, logger } = sock;
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -19,6 +21,82 @@ export const makeGroupsSocket = (config) => {
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
         return extractGroupMetadata(result);
     };
+    const groupMetadataCache = new Map();
+    const invalidateGroupMetadataCache = (jid) => {
+        if (jid)
+            groupMetadataCache.delete(jid);
+        else
+            groupMetadataCache.clear();
+    };
+    ev.on('group-participants.update', ({ id }) => invalidateGroupMetadataCache(id));
+    ev.on('groups.update', updates => {
+        for (const update of updates) {
+            if (update?.id)
+                invalidateGroupMetadataCache(update.id);
+        }
+    });
+    /**
+     * groupMetadata con cache corto (30s) para evitar golpear WhatsApp en checks repetidos
+     * (ej. isGroupAdmin llamado por cada mensaje). Se invalida automáticamente ante cualquier
+     * cambio real de participantes.
+     */
+    const groupMetadataCached = async (jid) => {
+        const cached = groupMetadataCache.get(jid);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.data;
+        }
+        const data = await groupMetadata(jid);
+        groupMetadataCache.set(jid, { data, expiresAt: Date.now() + GROUP_METADATA_CACHE_TTL_MS });
+        return data;
+    };
+    /**
+     * Resuelve un jid (que puede venir como @lid) a su jid de número de teléfono real.
+     */
+    const resolveParticipantJid = async (jidOrChatId, targetJid) => {
+        if (!targetJid)
+            return targetJid;
+        const normalized = jidNormalizedUser(targetJid);
+        if (!isLidUser(normalized))
+            return normalized;
+        const participants = Array.isArray(jidOrChatId) ? jidOrChatId : (await groupMetadataCached(jidOrChatId)).participants;
+        const match = participants.find(p => jidNormalizedUser(p.id) === normalized || (p.lid && jidNormalizedUser(p.lid) === normalized));
+        if (match?.phoneNumber)
+            return jidNormalizedUser(match.phoneNumber);
+        if (match?.jid && !isLidUser(match.jid))
+            return jidNormalizedUser(match.jid);
+        try {
+            const pn = await signalRepository.lidMapping.getPNForLID(normalized);
+            if (pn)
+                return jidNormalizedUser(pn);
+        }
+        catch (err) {
+            logger.trace({ err, jid: normalized }, 'no se pudo resolver LID a PN via signalRepository');
+        }
+        return normalized;
+    };
+    /** true si el jid (número o @lid) es admin/superadmin del grupo. */
+    const isGroupAdmin = async (jid, participantJid) => {
+        if (!participantJid)
+            return false;
+        const normalized = jidNormalizedUser(participantJid);
+        const meta = await groupMetadataCached(jid);
+        const participant = meta.participants.find(p => {
+            const pid = jidNormalizedUser(p.id);
+            return (pid === normalized ||
+                (p.lid && jidNormalizedUser(p.lid) === normalized) ||
+                (p.phoneNumber && jidNormalizedUser(p.phoneNumber) === normalized));
+        });
+        return participant?.admin === 'admin' || participant?.admin === 'superadmin';
+    };
+    /** Lista de admins del grupo ya resueltos a jid de número de teléfono (no @lid). */
+    const getGroupAdmins = async (jid) => {
+        const meta = await groupMetadataCached(jid);
+        const admins = meta.participants.filter(p => p.admin === 'admin' || p.admin === 'superadmin');
+        return Promise.all(admins.map(async (p) => ({
+            jid: await resolveParticipantJid(meta.participants, p.id),
+            admin: p.admin
+        })));
+    };
     const groupFetchAllParticipating = async () => {
         const result = await query({
             tag: 'iq',
@@ -66,6 +144,10 @@ export const makeGroupsSocket = (config) => {
     return {
         ...sock,
         groupMetadata,
+        groupMetadataCached,
+        resolveParticipantJid,
+        isGroupAdmin,
+        getGroupAdmins,
         groupCreate: async (subject, participants) => {
             const key = generateMessageIDV2();
             const result = await groupQuery('@g.us', 'set', [
@@ -182,23 +264,12 @@ export const makeGroupsSocket = (config) => {
             const result = getBinaryNodeChild(results, 'group');
             return result?.attrs.jid;
         },
-        /**
-         * revoke a v4 invite for someone
-         * @param groupJid group jid
-         * @param invitedJid jid of person you invited
-         * @returns true if successful
-         */
         groupRevokeInviteV4: async (groupJid, invitedJid) => {
             const result = await groupQuery(groupJid, 'set', [
                 { tag: 'revoke', attrs: {}, content: [{ tag: 'participant', attrs: { jid: invitedJid } }] }
             ]);
             return !!result;
         },
-        /**
-         * accept a GroupInviteMessage
-         * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
-         * @param inviteMessage the message to accept
-         */
         groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
             key = typeof key === 'string' ? { remoteJid: key } : key;
             const results = await groupQuery(inviteMessage.groupJid, 'set', [
@@ -211,10 +282,7 @@ export const makeGroupsSocket = (config) => {
                     }
                 }
             ]);
-            // if we have the full message key
-            // update the invite message to be expired
             if (key.id) {
-                // create new invite message that is expired
                 inviteMessage = proto.Message.GroupInviteMessage.fromObject(inviteMessage);
                 inviteMessage.inviteExpiration = 0;
                 inviteMessage.inviteCode = '';
@@ -229,7 +297,6 @@ export const makeGroupsSocket = (config) => {
                     }
                 ]);
             }
-            // generate the group add message
             await upsertMessage({
                 key: {
                     remoteJid: inviteMessage.groupJid,
@@ -270,16 +337,30 @@ export const makeGroupsSocket = (config) => {
 };
 export const extractGroupMetadata = (result) => {
     const group = getBinaryNodeChild(result, 'group');
+    if (!group) {
+        const errorNode = getBinaryNodeChild(result, 'error');
+        if (errorNode) {
+            const code = errorNode.attrs.code ? +errorNode.attrs.code : 500;
+            const text = errorNode.attrs.text || 'group metadata query failed';
+            throw new Boom(text, { statusCode: code, data: errorNode });
+        }
+        throw new Boom('Invalid group metadata response: missing <group> node', { data: result });
+    }
+    if (!group.attrs.id) {
+        throw new Boom('Invalid group metadata response: missing group id', { data: group });
+    }
     const descChild = getBinaryNodeChild(group, 'description');
     let desc;
     let descId;
     let descOwner;
     let descOwnerPn;
+    let descOwnerUsername;
     let descTime;
     if (descChild) {
         desc = getBinaryNodeChildString(descChild, 'body');
         descOwner = descChild.attrs.participant ? jidNormalizedUser(descChild.attrs.participant) : undefined;
         descOwnerPn = descChild.attrs.participant_pn ? jidNormalizedUser(descChild.attrs.participant_pn) : undefined;
+        descOwnerUsername = descChild.attrs.participant_username || undefined;
         descTime = +descChild.attrs.t;
         descId = descChild.attrs.id;
     }
@@ -293,16 +374,19 @@ export const extractGroupMetadata = (result) => {
         subject: group.attrs.subject,
         subjectOwner: group.attrs.s_o,
         subjectOwnerPn: group.attrs.s_o_pn,
+        subjectOwnerUsername: group.attrs.s_o_username,
         subjectTime: +group.attrs.s_t,
         size: group.attrs.size ? +group.attrs.size : getBinaryNodeChildren(group, 'participant').length,
         creation: +group.attrs.creation,
         owner: group.attrs.creator ? jidNormalizedUser(group.attrs.creator) : undefined,
         ownerPn: group.attrs.creator_pn ? jidNormalizedUser(group.attrs.creator_pn) : undefined,
+        ownerUsername: group.attrs.creator_username || undefined,
         owner_country_code: group.attrs.creator_country_code,
         desc,
         descId,
         descOwner,
         descOwnerPn,
+        descOwnerUsername,
         descTime,
         linkedParent: getBinaryNodeChild(group, 'linked_parent')?.attrs.jid || undefined,
         restrict: !!getBinaryNodeChild(group, 'locked'),
@@ -314,9 +398,9 @@ export const extractGroupMetadata = (result) => {
         participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
             return {
                 id: attrs.jid,
-                jid: attrs.phone_number || attrs.jid,
                 phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
                 lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                username: attrs.participant_username || attrs.username || undefined,
                 admin: (attrs.type || null)
             };
         }),
@@ -324,4 +408,3 @@ export const extractGroupMetadata = (result) => {
     };
     return metadata;
 };
-//# sourceMappingURL=groups.js.map

package/lib/Socket/messages-recv.js

@@ -764,9 +764,26 @@ export const makeMessagesRecvSocket = (config) => {
         // Check if we should recreate session for this retry
         let shouldRecreateSession = false;
         let recreateReason = '';
+        const sessionId = signalRepository.jidToSignalProtocolAddress(participant);
+        const BASE_KEY_CHECK_RETRY = 2;
+        const primaryMsgId = ids[0];
+        if (primaryMsgId && messageRetryManager) {
+            const baseKeyInfo = await signalRepository.getSessionInfo(participant);
+            if (baseKeyInfo) {
+                if (retryCount === BASE_KEY_CHECK_RETRY) {
+                    messageRetryManager.saveBaseKey(sessionId, primaryMsgId, baseKeyInfo.baseKey);
+                }
+                else if (retryCount > BASE_KEY_CHECK_RETRY) {
+                    if (messageRetryManager.hasSameBaseKey(sessionId, primaryMsgId, baseKeyInfo.baseKey)) {
+                        logger.warn({ participant, retryCount }, 'base key collision on retry, forcing fresh session');
+                        await authState.keys.set({ session: { [sessionId]: null } });
+                    }
+                    messageRetryManager.deleteBaseKey(sessionId, primaryMsgId);
+                }
+            }
+        }
         if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
             try {
-                const sessionId = signalRepository.jidToSignalProtocolAddress(participant);
                 const hasSession = await signalRepository.validateSession(participant);
                 const result = messageRetryManager.shouldRecreateSession(participant, hasSession.exists);
                 shouldRecreateSession = result.recreate;

package/lib/Socket/newsletter.js

@@ -200,7 +200,7 @@ export const makeNewsletterSocket = (config) => {
         await executeWMexQuery(
           { newsletter_id: id },
           QueryIds.FOLLOW,
-          XWAPaths.xwa2_newsletter_follow,
+          XWAPaths.xwa2_newsletter_join_v2,
         );
         await new Promise((resolve) => setTimeout(resolve, 550));
       }
@@ -297,14 +297,14 @@ export const makeNewsletterSocket = (config) => {
       return executeWMexQuery(
         { newsletter_id: jid },
         QueryIds.FOLLOW,
-        XWAPaths.xwa2_newsletter_follow,
+        XWAPaths.xwa2_newsletter_join_v2,
       );
     },
     newsletterUnfollow: (jid) => {
       return executeWMexQuery(
         { newsletter_id: jid },
         QueryIds.UNFOLLOW,
-        XWAPaths.xwa2_newsletter_unfollow,
+        XWAPaths.xwa2_newsletter_leave_v2,
       );
     },
     newsletterMute: (jid) => {

package/lib/Socket/socket.js

@@ -4,13 +4,14 @@ import { URL } from 'url';
 import { promisify } from 'util';
 import { proto } from '../../WAProto/index.js';
 import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/index.js';
-import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
-import { getPlatformId } from '../Utils/browser-utils.js';
+import { QueryIds, ReachoutTimelockEnforcementType } from '../Types/index.js';
+import { DisconnectReason, XWAPaths } from '../Types/index.js';
+import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, buildPairingQRData, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getCompanionPlatformId, getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
 import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildren, isLidUser, jidDecode, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { BinaryInfo } from '../WAM/BinaryInfo.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { WebSocketClient } from './Client/index.js';
+import { executeWMexQuery } from './mex.js';
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -26,6 +27,9 @@ export const makeSocket = (config) => {
     if (printQRInTerminal) {
         logger.warn({}, '⚠️ The printQRInTerminal option has been deprecated. You will no longer receive QR codes in the terminal automatically. Please listen to the connection.update event yourself and handle the QR your way. You can remove this message by removing this opttion. This message will be removed in a future version.');
     }
+    if (browser[1].toLocaleLowerCase().includes('android')) {
+        logger.warn('⚠️ Using the Android browser is experimental and may lead to unexpected behavior. Use at your own risk.');
+    }
     const syncDisabled = PROCESSABLE_HISTORY_TYPES.map(syncType => config.shouldSyncHistoryMessage({ syncType })).filter(x => x === false)
         .length === PROCESSABLE_HISTORY_TYPES.length;
     if (syncDisabled) {
@@ -270,6 +274,7 @@ export const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    const socketEndHandlers = [];
     /** log & process any unexpected errors */
     const onUnexpectedError = (err, msg) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
@@ -411,6 +416,32 @@ export const makeSocket = (config) => {
         const exists = !!preKeys[currentPreKeyId.toString()];
         return { exists, currentPreKeyId };
     };
+    const registerSocketEndHandler = (handler) => {
+        socketEndHandlers.push(handler);
+    };
+    /**
+     * Fetches your account's standing when it comes to restrictions.
+     * @returns Returns the state of the restrictions.
+     */
+    const fetchAccountReachoutTimelock = async () => {
+        const queryResult = await executeWMexQuery({}, QueryIds.REACHOUT_TIMELOCK, XWAPaths.xwa2_fetch_account_reachout_timelock, query, generateMessageTag);
+        const result = {
+            isActive: !!queryResult?.is_active,
+            timeEnforcementEnds: queryResult?.time_enforcement_ends && queryResult?.time_enforcement_ends !== '0'
+                ? new Date(parseInt(queryResult.time_enforcement_ends, 10) * 1000)
+                : undefined,
+            enforcementType: queryResult?.enforcement_type ?? ReachoutTimelockEnforcementType.DEFAULT
+        };
+        ev.emit('connection.update', { reachoutTimeLock: result });
+        return result;
+    };
+    /**
+     * Fetches your account's new chat limits.
+     * @returns Returns the quota and the usage.
+     */
+    const fetchNewChatMessageCap = async () => {
+        return executeWMexQuery({ input: { type: 'INDIVIDUAL_NEW_CHAT_MSG' } }, QueryIds.MESSAGE_CAPPING_INFO, XWAPaths.xwa2_message_capping_info, query, generateMessageTag);
+    };
     const uploadPreKeysToServerIfRequired = async () => {
         try {
             let count = 0;
@@ -486,12 +517,21 @@ export const makeSocket = (config) => {
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
+        signalRepository.close?.();
         if (!ws.isClosed && !ws.isClosing) {
             try {
                 await ws.close();
             }
             catch { }
         }
+        for (const handler of socketEndHandlers) {
+            try {
+                await handler(error);
+            }
+            catch (err) {
+                logger.error({ err }, 'error in socket end handler');
+            }
+        }
         ev.emit('connection.update', {
             connection: 'close',
             lastDisconnect: {
@@ -500,6 +540,7 @@ export const makeSocket = (config) => {
             }
         });
         ev.removeAllListeners('connection.update');
+        ev.destroy();
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
@@ -629,7 +670,7 @@ export const makeSocket = (config) => {
                         {
                             tag: 'companion_platform_id',
                             attrs: {},
-                            content: getPlatformId(browser[1])
+                            content: getCompanionPlatformId(browser)
                         },
                         {
                             tag: 'companion_platform_display',
@@ -712,7 +753,7 @@ export const makeSocket = (config) => {
                 return;
             }
             const ref = refNode.content.toString('utf-8');
-            const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(',');
+            const qr = buildPairingQRData(ref, noiseKeyB64, identityKeyB64, advB64, browser);
             ev.emit('connection.update', { qr });
             qrTimer = setTimeout(genPairQR, qrMs);
             qrMs = qrTimeout || 20000; // shorter subsequent qrs
@@ -921,7 +962,10 @@ export const makeSocket = (config) => {
         waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
         executeUSyncQuery,
-        onWhatsApp
+        registerSocketEndHandler,
+        onWhatsApp,
+        fetchAccountReachoutTimelock,
+        fetchNewChatMessageCap
     };
 };
 /**

package/lib/Types/Newsletter.d.ts

@@ -8,23 +8,32 @@ export declare enum XWAPaths {
     xwa2_newsletter_unmute_v2 = "xwa2_newsletter_unmute_v2",
     xwa2_newsletter_follow = "xwa2_newsletter_follow",
     xwa2_newsletter_unfollow = "xwa2_newsletter_unfollow",
+    xwa2_newsletter_join_v2 = "xwa2_newsletter_join_v2",
+    xwa2_newsletter_leave_v2 = "xwa2_newsletter_leave_v2",
     xwa2_newsletter_change_owner = "xwa2_newsletter_change_owner",
     xwa2_newsletter_demote = "xwa2_newsletter_demote",
-    xwa2_newsletter_delete_v2 = "xwa2_newsletter_delete_v2"
+    xwa2_newsletter_delete_v2 = "xwa2_newsletter_delete_v2",
+    xwa2_fetch_account_reachout_timelock = "xwa2_fetch_account_reachout_timelock",
+    xwa2_message_capping_info = "xwa2_message_capping_info"
+}
+export declare enum ReachoutTimelockEnforcementType {
+    DEFAULT = "DEFAULT"
 }
 export declare enum QueryIds {
     CREATE = "8823471724422422",
     UPDATE_METADATA = "24250201037901610",
     METADATA = "6563316087068696",
     SUBSCRIBERS = "9783111038412085",
-    FOLLOW = "7871414976211147",
-    UNFOLLOW = "7238632346214362",
+    FOLLOW = "24404358912487870",
+    UNFOLLOW = "9767147403369991",
     MUTE = "29766401636284406",
     UNMUTE = "9864994326891137",
     ADMIN_COUNT = "7130823597031706",
     CHANGE_OWNER = "7341777602580933",
     DEMOTE = "6551828931592903",
-    DELETE = "30062808666639665"
+    DELETE = "30062808666639665",
+    REACHOUT_TIMELOCK = "23983697327930364",
+    MESSAGE_CAPPING_INFO = "24503548349331633"
 }
 export type NewsletterUpdate = {
     name?: string;

package/lib/Types/Newsletter.js

@@ -9,23 +9,33 @@ export var XWAPaths;
     XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
     XWAPaths["xwa2_newsletter_follow"] = "xwa2_newsletter_follow";
     XWAPaths["xwa2_newsletter_unfollow"] = "xwa2_newsletter_unfollow";
+    XWAPaths["xwa2_newsletter_join_v2"] = "xwa2_newsletter_join_v2";
+    XWAPaths["xwa2_newsletter_leave_v2"] = "xwa2_newsletter_leave_v2";
     XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
     XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_demote";
     XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+    XWAPaths["xwa2_fetch_account_reachout_timelock"] = "xwa2_fetch_account_reachout_timelock";
+    XWAPaths["xwa2_message_capping_info"] = "xwa2_message_capping_info";
 })(XWAPaths || (XWAPaths = {}));
+export var ReachoutTimelockEnforcementType;
+(function (ReachoutTimelockEnforcementType) {
+    ReachoutTimelockEnforcementType["DEFAULT"] = "DEFAULT";
+})(ReachoutTimelockEnforcementType || (ReachoutTimelockEnforcementType = {}));
 export var QueryIds;
 (function (QueryIds) {
     QueryIds["CREATE"] = "8823471724422422";
     QueryIds["UPDATE_METADATA"] = "24250201037901610";
     QueryIds["METADATA"] = "6563316087068696";
     QueryIds["SUBSCRIBERS"] = "9783111038412085";
-    QueryIds["FOLLOW"] = "7871414976211147";
-    QueryIds["UNFOLLOW"] = "7238632346214362";
+    QueryIds["FOLLOW"] = "24404358912487870";
+    QueryIds["UNFOLLOW"] = "9767147403369991";
     QueryIds["MUTE"] = "29766401636284406";
     QueryIds["UNMUTE"] = "9864994326891137";
     QueryIds["ADMIN_COUNT"] = "7130823597031706";
     QueryIds["CHANGE_OWNER"] = "7341777602580933";
     QueryIds["DEMOTE"] = "6551828931592903";
     QueryIds["DELETE"] = "30062808666639665";
+    QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+    QueryIds["MESSAGE_CAPPING_INFO"] = "24503548349331633";
 })(QueryIds || (QueryIds = {}));
 //# sourceMappingURL=Newsletter.js.map

package/lib/Utils/chat-utils.d.ts

@@ -6,13 +6,43 @@ type FetchAppStateSyncKey = (keyId: string) => Promise<proto.Message.IAppStateSy
 export type ChatMutationMap = {
     [index: string]: ChatMutation;
 };
+type Mac = {
+    indexMac: Uint8Array;
+    valueMac: Uint8Array;
+    operation: proto.SyncdMutation.SyncdOperation;
+};
+export declare const makeLtHashGenerator: ({ indexValueMap, hash }: Pick<LTHashState, "hash" | "indexValueMap">) => {
+    mix: ({ indexMac, valueMac, operation }: Mac) => void;
+    finish: () => {
+        hash: Buffer<ArrayBuffer>;
+        indexValueMap: {
+            [indexMacBase64: string]: {
+                valueMac: Uint8Array | Buffer;
+            };
+        };
+    };
+};
 export declare const newLTHashState: () => LTHashState;
+export declare const ensureLTHashStateVersion: (state: LTHashState) => LTHashState;
+export declare 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 declare const isMissingKeyError: (error: any) => boolean;
+/**
+ * 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 declare const isAppStateSyncIrrecoverable: (error: any, attempts: number) => boolean;
 export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, operation }: WAPatchCreate, myAppStateKeyId: string, state: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey) => Promise<{
     patch: proto.ISyncdPatch;
     state: LTHashState;
 }>;
 export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: Buffer;
+    hash: Buffer<ArrayBuffer>;
     indexValueMap: {
         [indexMacBase64: string]: {
             valueMac: Uint8Array | Buffer;
@@ -20,7 +50,7 @@ export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation
     };
 }>;
 export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchName, initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: Buffer;
+    hash: Buffer<ArrayBuffer>;
     indexValueMap: {
         [indexMacBase64: string]: {
             valueMac: Uint8Array | Buffer;
@@ -54,9 +84,9 @@ export declare const extractSyncdPatches: (result: BinaryNode, options: RequestI
         snapshot?: proto.ISyncdSnapshot;
     };
 }>;
-export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: RequestInit) => Promise<Buffer>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: RequestInit) => Promise<Buffer<ArrayBuffer>>;
 export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: RequestInit) => Promise<proto.SyncdMutations>;
-export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
+export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean, logger?: ILogger) => Promise<{
     state: LTHashState;
     mutationMap: ChatMutationMap;
 }>;