@aseppxyzz12/baileys 1.1.8

package/lib/Socket/chats.js

@@ -0,0 +1,874 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { default: NodeCache } = require("@cacheable/node-cache");
+const { Boom: Boom } = require("@hapi/boom");
+const { proto: proto } = require("../../WAProto");
+const {
+    CALL_VIDEO_PREFIX: CALL_VIDEO_PREFIX,
+    CALL_AUDIO_PREFIX: CALL_AUDIO_PREFIX,
+} = require("../Defaults/prefix");
+const { DEFAULT_CACHE_TTLS: DEFAULT_CACHE_TTLS } = require("../Defaults/constants");
+const { PROCESSABLE_HISTORY_TYPES: PROCESSABLE_HISTORY_TYPES } = require("../Defaults/history");
+const { SyncState: SyncState, ALL_WA_PATCH_NAMES: ALL_WA_PATCH_NAMES } = require("../Types");
+const {
+    newLTHashState: newLTHashState,
+    processSyncAction: processSyncAction,
+    extractSyncdPatches: extractSyncdPatches,
+    generateProfilePicture: generateProfilePicture,
+    decodeSyncdSnapshot: decodeSyncdSnapshot,
+    decodePatches: decodePatches,
+    encodeSyncdPatch: encodeSyncdPatch,
+    chatModificationToAppPatch: chatModificationToAppPatch,
+    getHistoryMsg: getHistoryMsg,
+    processMessage: processMessage,
+} = require("../Utils");
+const { makeMutex: makeMutex } = require("../Utils/make-mutex");
+const {
+    isPnUser: isPnUser,
+    getBinaryNodeChild: getBinaryNodeChild,
+    getBinaryNodeChildren: getBinaryNodeChildren,
+    jidDecode: jidDecode,
+    jidNormalizedUser: jidNormalizedUser,
+    reduceBinaryNodeToDictionary: reduceBinaryNodeToDictionary,
+    S_WHATSAPP_NET: S_WHATSAPP_NET,
+} = require("../WABinary");
+const { USyncUser: USyncUser, USyncQuery: USyncQuery } = require("../WAUSync");
+const { makeSocket: makeSocket } = require("./socket");
+const MAX_SYNC_ATTEMPTS = 2;
+const makeChatsSocket = (config) => {
+    const {
+        logger: logger,
+        markOnlineOnConnect: markOnlineOnConnect,
+        fireInitQueries: fireInitQueries,
+        appStateMacVerification: appStateMacVerification,
+        shouldIgnoreJid: shouldIgnoreJid,
+        shouldSyncHistoryMessage: shouldSyncHistoryMessage,
+        getMessage: getMessage,
+    } = config;
+    const conn = makeSocket(config);
+    const {
+        ev: ev,
+        ws: ws,
+        authState: authState,
+        generateMessageTag: generateMessageTag,
+        sendNode: sendNode,
+        query: query,
+        signalRepository: signalRepository,
+        onUnexpectedError: onUnexpectedError,
+    } = conn;
+    let privacySettings;
+    let syncState = SyncState.Connecting;
+    const messageMutex = makeMutex();
+    const receiptMutex = makeMutex();
+    const appStatePatchMutex = makeMutex();
+    const notificationMutex = makeMutex();
+    let awaitingSyncTimeout;
+    const placeholderResendCache =
+        config.placeholderResendCache ||
+        new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, useClones: false });
+    if (!config.placeholderResendCache) {
+        config.placeholderResendCache = placeholderResendCache;
+    }
+    const getAppStateSyncKey = async (keyId) => {
+        const { [keyId]: key } = await authState.keys.get("app-state-sync-key", [keyId]);
+        return key;
+    };
+    const fetchPrivacySettings = async (force = false) => {
+        if (!privacySettings || force) {
+            const { content: content } = await query({
+                tag: "iq",
+                attrs: { xmlns: "privacy", to: S_WHATSAPP_NET, type: "get" },
+                content: [{ tag: "privacy", attrs: {} }],
+            });
+            privacySettings = reduceBinaryNodeToDictionary(content?.[0], "category");
+        }
+        return privacySettings;
+    };
+    const privacyQuery = async (name, value) => {
+        await query({
+            tag: "iq",
+            attrs: { xmlns: "privacy", to: S_WHATSAPP_NET, type: "set" },
+            content: [
+                {
+                    tag: "privacy",
+                    attrs: {},
+                    content: [{ tag: "category", attrs: { name: name, value: value } }],
+                },
+            ],
+        });
+    };
+    const updateMessagesPrivacy = async (value) => {
+        await privacyQuery("messages", value);
+    };
+    const updateCallPrivacy = async (value) => {
+        await privacyQuery("calladd", value);
+    };
+    const updateLastSeenPrivacy = async (value) => {
+        await privacyQuery("last", value);
+    };
+    const updateOnlinePrivacy = async (value) => {
+        await privacyQuery("online", value);
+    };
+    const updateProfilePicturePrivacy = async (value) => {
+        await privacyQuery("profile", value);
+    };
+    const updateStatusPrivacy = async (value) => {
+        await privacyQuery("status", value);
+    };
+    const updateReadReceiptsPrivacy = async (value) => {
+        await privacyQuery("readreceipts", value);
+    };
+    const updateGroupsAddPrivacy = async (value) => {
+        await privacyQuery("groupadd", value);
+    };
+    const updateDefaultDisappearingMode = async (duration) => {
+        await query({
+            tag: "iq",
+            attrs: { xmlns: "disappearing_mode", to: S_WHATSAPP_NET, type: "set" },
+            content: [{ tag: "disappearing_mode", attrs: { duration: duration.toString() } }],
+        });
+    };
+    const getBotListV2 = async () => {
+        const resp = await query({
+            tag: "iq",
+            attrs: { xmlns: "bot", to: S_WHATSAPP_NET, type: "get" },
+            content: [{ tag: "bot", attrs: { v: "2" } }],
+        });
+        const botNode = getBinaryNodeChild(resp, "bot");
+        const botList = [];
+        for (const section of getBinaryNodeChildren(botNode, "section")) {
+            if (section.attrs.type === "all") {
+                for (const bot of getBinaryNodeChildren(section, "bot")) {
+                    botList.push({
+                        jid: bot.attrs.jid,
+                        personaId: bot.attrs["persona_id"],
+                    });
+                }
+            }
+        }
+        return botList;
+    };
+    const getLidUser = async (jid) => {
+        if (!jid) {
+            throw new Boom("Please input a jid user");
+        }
+        if (!isPnUser(jid)) {
+            throw new Boom("Invalid JID: Not a user JID!");
+        }
+        const targetJid = jidNormalizedUser(jid);
+        const usyncQuery = new USyncQuery();
+        usyncQuery.protocols.push({
+            name: "lid",
+            getQueryElement: () => ({ tag: "lid", attrs: {}, content: undefined }),
+            getUserElement: () => null,
+            parser: (node) => node.attrs.val,
+        });
+        usyncQuery.users.push({ id: targetJid });
+        const result = await conn.executeUSyncQuery(usyncQuery);
+        if (result) {
+            return result.list;
+        }
+    };
+    const fetchStatus = async (...jids) => {
+        const usyncQuery = new USyncQuery().withStatusProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new USyncUser().withId(jid));
+        }
+        const result = await conn.executeUSyncQuery(usyncQuery);
+        if (result) {
+            return result.list;
+        }
+    };
+    const fetchDisappearingDuration = async (...jids) => {
+        const usyncQuery = new USyncQuery().withDisappearingModeProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new USyncUser().withId(jid));
+        }
+        const result = await conn.executeUSyncQuery(usyncQuery);
+        if (result) {
+            return result.list;
+        }
+    };
+    const updateProfilePicture = async (jid, content, dimensions) => {
+        let targetJid;
+        if (!jid) {
+            throw new Boom(
+                "Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update"
+            );
+        }
+        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
+            targetJid = jidNormalizedUser(jid);
+        } else {
+            targetJid = undefined;
+        }
+        const { img: img } = await generateProfilePicture(content, dimensions);
+        await query({
+            tag: "iq",
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: "set",
+                xmlns: "w:profile:picture",
+                ...(targetJid ? { target: targetJid } : {}),
+            },
+            content: [{ tag: "picture", attrs: { type: "image" }, content: img }],
+        });
+    };
+    const removeProfilePicture = async (jid) => {
+        let targetJid;
+        if (!jid) {
+            throw new Boom(
+                "Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update"
+            );
+        }
+        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
+            targetJid = jidNormalizedUser(jid);
+        } else {
+            targetJid = undefined;
+        }
+        await query({
+            tag: "iq",
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: "set",
+                xmlns: "w:profile:picture",
+                ...(targetJid ? { target: targetJid } : {}),
+            },
+        });
+    };
+    const updateProfileStatus = async (status) => {
+        await query({
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "status" },
+            content: [{ tag: "status", attrs: {}, content: Buffer.from(status, "utf-8") }],
+        });
+    };
+    const updateProfileName = async (name) => {
+        await chatModify({ pushNameSetting: name }, "");
+    };
+    const fetchBlocklist = async () => {
+        const result = await query({
+            tag: "iq",
+            attrs: { xmlns: "blocklist", to: S_WHATSAPP_NET, type: "get" },
+        });
+        const listNode = getBinaryNodeChild(result, "list");
+        return getBinaryNodeChildren(listNode, "item").map((n) => n.attrs.jid);
+    };
+    const updateBlockStatus = async (jid, action) => {
+        await query({
+            tag: "iq",
+            attrs: { xmlns: "blocklist", to: S_WHATSAPP_NET, type: "set" },
+            content: [{ tag: "item", attrs: { action: action, jid: jid } }],
+        });
+    };
+    const getBusinessProfile = async (jid) => {
+        const results = await query({
+            tag: "iq",
+            attrs: { to: "s.whatsapp.net", xmlns: "w:biz", type: "get" },
+            content: [
+                {
+                    tag: "business_profile",
+                    attrs: { v: "244" },
+                    content: [{ tag: "profile", attrs: { jid: jid } }],
+                },
+            ],
+        });
+        const profileNode = getBinaryNodeChild(results, "business_profile");
+        const profiles = getBinaryNodeChild(profileNode, "profile");
+        if (profiles) {
+            const address = getBinaryNodeChild(profiles, "address");
+            const description = getBinaryNodeChild(profiles, "description");
+            const website = getBinaryNodeChild(profiles, "website");
+            const email = getBinaryNodeChild(profiles, "email");
+            const category = getBinaryNodeChild(
+                getBinaryNodeChild(profiles, "categories"),
+                "category"
+            );
+            const businessHours = getBinaryNodeChild(profiles, "business_hours");
+            const businessHoursConfig = businessHours
+                ? getBinaryNodeChildren(businessHours, "business_hours_config")
+                : undefined;
+            const websiteStr = website?.content?.toString();
+            return {
+                wid: profiles?.attrs?.jid,
+                address: address?.content?.toString(),
+                description: description?.content?.toString() || "",
+                website: websiteStr ? [websiteStr] : [],
+                email: email?.content?.toString(),
+                category: category?.content?.toString(),
+                business_hours: {
+                    timezone: businessHours?.attrs?.timezone,
+                    business_config: businessHoursConfig?.map(({ attrs: attrs }) => attrs),
+                },
+            };
+        }
+    };
+    const cleanDirtyBits = async (type, fromTimestamp) => {
+        logger.info({ fromTimestamp: fromTimestamp }, "clean dirty bits " + type);
+        await sendNode({
+            tag: "iq",
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: "set",
+                xmlns: "urn:xmpp:whatsapp:dirty",
+                id: generateMessageTag(),
+            },
+            content: [
+                {
+                    tag: "clean",
+                    attrs: {
+                        type: type,
+                        ...(fromTimestamp ? { timestamp: fromTimestamp.toString() } : null),
+                    },
+                },
+            ],
+        });
+    };
+    const newAppStateChunkHandler = (isInitialSync) => ({
+        onMutation(mutation) {
+            processSyncAction(
+                mutation,
+                ev,
+                authState.creds.me,
+                isInitialSync ? { accountSettings: authState.creds.accountSettings } : undefined,
+                logger
+            );
+        },
+    });
+    const resyncAppState = ev.createBufferedFunction(async (collections, isInitialSync) => {
+        const initialVersionMap = {};
+        const globalMutationMap = {};
+        await authState.keys.transaction(async () => {
+            const collectionsToHandle = new Set(collections);
+            const attemptsMap = {};
+            while (collectionsToHandle.size) {
+                const states = {};
+                const nodes = [];
+                for (const name of collectionsToHandle) {
+                    const result = await authState.keys.get("app-state-sync-version", [name]);
+                    let state = result[name];
+                    if (state) {
+                        if (typeof initialVersionMap[name] === "undefined") {
+                            initialVersionMap[name] = state.version;
+                        }
+                    } else {
+                        state = newLTHashState();
+                    }
+                    states[name] = state;
+                    logger.info(`resyncing ${name} from v${state.version}`);
+                    nodes.push({
+                        tag: "collection",
+                        attrs: {
+                            name: name,
+                            version: state.version.toString(),
+                            return_snapshot: (!state.version).toString(),
+                        },
+                    });
+                }
+                const result = await query({
+                    tag: "iq",
+                    attrs: {
+                        to: S_WHATSAPP_NET,
+                        xmlns: "w:sync:app:state",
+                        type: "set",
+                    },
+                    content: [{ tag: "sync", attrs: {}, content: nodes }],
+                });
+                const decoded = await extractSyncdPatches(result, config?.options);
+                for (const key in decoded) {
+                    const name = key;
+                    const {
+                        patches: patches,
+                        hasMorePatches: hasMorePatches,
+                        snapshot: snapshot,
+                    } = decoded[name];
+                    try {
+                        if (snapshot) {
+                            const { state: newState, mutationMap: mutationMap } =
+                                await decodeSyncdSnapshot(
+                                    name,
+                                    snapshot,
+                                    getAppStateSyncKey,
+                                    initialVersionMap[name],
+                                    appStateMacVerification.snapshot
+                                );
+                            states[name] = newState;
+                            Object.assign(globalMutationMap, mutationMap);
+                            logger.info(
+                                `restored state of ${name} from snapshot to v${newState.version} with mutations`
+                            );
+                            await authState.keys.set({
+                                "app-state-sync-version": { [name]: newState },
+                            });
+                        }
+                        if (patches.length) {
+                            const { state: newState, mutationMap: mutationMap } =
+                                await decodePatches(
+                                    name,
+                                    patches,
+                                    states[name],
+                                    getAppStateSyncKey,
+                                    config.options,
+                                    initialVersionMap[name],
+                                    logger,
+                                    appStateMacVerification.patch
+                                );
+                            await authState.keys.set({
+                                "app-state-sync-version": { [name]: newState },
+                            });
+                            logger.info(`synced ${name} to v${newState.version}`);
+                            initialVersionMap[name] = newState.version;
+                            Object.assign(globalMutationMap, mutationMap);
+                        }
+                        if (hasMorePatches) {
+                            logger.info(`${name} has more patches...`);
+                        } else {
+                            collectionsToHandle.delete(name);
+                        }
+                    } catch (error) {
+                        const isIrrecoverableError =
+                            attemptsMap[name] >= MAX_SYNC_ATTEMPTS ||
+                            error.output?.statusCode === 404 ||
+                            error.name === "TypeError";
+                        logger.info(
+                            { name: name, error: error.stack },
+                            `failed to sync state from version${isIrrecoverableError ? "" : ", removing and trying from scratch"}`
+                        );
+                        await authState.keys.set({
+                            "app-state-sync-version": { [name]: null },
+                        });
+                        attemptsMap[name] = (attemptsMap[name] || 0) + 1;
+                        if (isIrrecoverableError) {
+                            collectionsToHandle.delete(name);
+                        }
+                    }
+                }
+            }
+        }, authState?.creds?.me?.id || "resync-app-state");
+        const { onMutation: onMutation } = newAppStateChunkHandler(isInitialSync);
+        for (const key in globalMutationMap) {
+            onMutation(globalMutationMap[key]);
+        }
+    });
+    const createCallLink = async (type, event, timeoutMs) => {
+        type = type?.toLowerCase();
+        if (!type || (type !== "audio" && type !== "video")) {
+            throw new Error("Make sure the type is audio or video!");
+        }
+        const result = await query(
+            {
+                tag: "call",
+                attrs: { id: generateMessageTag(), to: "@call" },
+                content: [
+                    {
+                        tag: "link_create",
+                        attrs: { media: type },
+                        content: event
+                            ? [{ tag: "event", attrs: { start_time: String(event) } }]
+                            : undefined,
+                    },
+                ],
+            },
+            timeoutMs
+        );
+        const child = getBinaryNodeChild(result, "link_create");
+        const token = child?.attrs?.token;
+        return type === "audio" ? CALL_AUDIO_PREFIX + token : CALL_VIDEO_PREFIX + token;
+    };
+    const sendPresenceUpdate = async (type, toJid) => {
+        const me = authState.creds.me;
+        if (type === "available" || type === "unavailable") {
+            if (!me.name) {
+                logger.warn("no name present, ignoring presence update request...");
+                return;
+            }
+            ev.emit("connection.update", { isOnline: type === "available" });
+            await sendNode({
+                tag: "presence",
+                attrs: { name: me.name.replace(/@/g, ""), type: type },
+            });
+        } else {
+            const { server: server } = jidDecode(toJid);
+            await sendNode({
+                tag: "chatstate",
+                attrs: { from: server === "lid" ? me.lid : me.id, to: toJid },
+                content: [
+                    {
+                        tag: type === "recording" ? "composing" : type,
+                        attrs: type === "recording" ? { media: "audio" } : {},
+                    },
+                ],
+            });
+        }
+    };
+    const presenceSubscribe = (toJid, tcToken) =>
+        sendNode({
+            tag: "presence",
+            attrs: { to: toJid, id: generateMessageTag(), type: "subscribe" },
+            content: tcToken ? [{ tag: "tctoken", attrs: {}, content: tcToken }] : undefined,
+        });
+    const handlePresenceUpdate = ({ tag: tag, attrs: attrs, content: content }) => {
+        let presence;
+        const jid = attrs.from;
+        const participant = attrs.participant || attrs.from;
+        if (shouldIgnoreJid(jid) && jid !== S_WHATSAPP_NET) {
+            return;
+        }
+        if (tag === "presence") {
+            presence = {
+                lastKnownPresence: attrs.type === "unavailable" ? "unavailable" : "available",
+                lastSeen: attrs.last && attrs.last !== "deny" ? +attrs.last : undefined,
+            };
+        } else if (Array.isArray(content)) {
+            const [firstChild] = content;
+            let type = firstChild.tag;
+            if (type === "paused") {
+                type = "available";
+            }
+            if (firstChild.attrs?.media === "audio") {
+                type = "recording";
+            }
+            presence = { lastKnownPresence: type };
+        } else {
+            logger.error(
+                { tag: tag, attrs: attrs, content: content },
+                "recv invalid presence node"
+            );
+        }
+        if (presence) {
+            ev.emit("presence.update", {
+                id: jid,
+                presences: { [participant]: presence },
+            });
+        }
+    };
+    const appPatch = async (patchCreate) => {
+        const name = patchCreate.type;
+        const myAppStateKeyId = authState.creds.myAppStateKeyId;
+        if (!myAppStateKeyId) {
+            throw new Boom("App state key not present!", { statusCode: 400 });
+        }
+        let initial;
+        let encodeResult;
+        await appStatePatchMutex.mutex(async () => {
+            await authState.keys.transaction(async () => {
+                logger.debug({ patch: patchCreate }, "applying app patch");
+                await resyncAppState([name], false);
+                const { [name]: currentSyncVersion } = await authState.keys.get(
+                    "app-state-sync-version",
+                    [name]
+                );
+                initial = currentSyncVersion || newLTHashState();
+                encodeResult = await encodeSyncdPatch(
+                    patchCreate,
+                    myAppStateKeyId,
+                    initial,
+                    getAppStateSyncKey
+                );
+                const { patch: patch, state: state } = encodeResult;
+                const node = {
+                    tag: "iq",
+                    attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:sync:app:state" },
+                    content: [
+                        {
+                            tag: "sync",
+                            attrs: {},
+                            content: [
+                                {
+                                    tag: "collection",
+                                    attrs: {
+                                        name: name,
+                                        version: (state.version - 1).toString(),
+                                        return_snapshot: "false",
+                                    },
+                                    content: [
+                                        {
+                                            tag: "patch",
+                                            attrs: {},
+                                            content: proto.SyncdPatch.encode(patch).finish(),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                };
+                await query(node);
+                await authState.keys.set({
+                    "app-state-sync-version": { [name]: state },
+                });
+            }, authState?.creds?.me?.id || "app-patch");
+        });
+        if (config.emitOwnEvents) {
+            const { onMutation: onMutation } = newAppStateChunkHandler(false);
+            const { mutationMap: mutationMap } = await decodePatches(
+                name,
+                [
+                    {
+                        ...encodeResult.patch,
+                        version: { version: encodeResult.state.version },
+                    },
+                ],
+                initial,
+                getAppStateSyncKey,
+                config.options,
+                undefined,
+                logger
+            );
+            for (const key in mutationMap) {
+                onMutation(mutationMap[key]);
+            }
+        }
+    };
+    const fetchProps = async () => {
+        const resultNode = await query({
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, xmlns: "w", type: "get" },
+            content: [
+                {
+                    tag: "props",
+                    attrs: { protocol: "2", hash: authState?.creds?.lastPropHash || "" },
+                },
+            ],
+        });
+        const propsNode = getBinaryNodeChild(resultNode, "props");
+        let props = {};
+        if (propsNode) {
+            if (propsNode.attrs?.hash) {
+                authState.creds.lastPropHash = propsNode?.attrs?.hash;
+                ev.emit("creds.update", authState.creds);
+            }
+            props = reduceBinaryNodeToDictionary(propsNode, "prop");
+        }
+        logger.debug("fetched props");
+        return props;
+    };
+    const chatModify = (mod, jid) => {
+        const patch = chatModificationToAppPatch(mod, jid);
+        return appPatch(patch);
+    };
+    const updateDisableLinkPreviewsPrivacy = (isPreviewsDisabled) =>
+        chatModify({ disableLinkPreviews: { isPreviewsDisabled: isPreviewsDisabled } }, "");
+    const star = (jid, messages, star) =>
+        chatModify({ star: { messages: messages, star: star } }, jid);
+    const addOrEditContact = (jid, contact) => chatModify({ contact: contact }, jid);
+    const removeContact = (jid) => chatModify({ contact: null }, jid);
+    const addLabel = (jid, labels) => chatModify({ addLabel: { ...labels } }, jid);
+    const addChatLabel = (jid, labelId) => chatModify({ addChatLabel: { labelId: labelId } }, jid);
+    const removeChatLabel = (jid, labelId) =>
+        chatModify({ removeChatLabel: { labelId: labelId } }, jid);
+    const addMessageLabel = (jid, messageId, labelId) =>
+        chatModify({ addMessageLabel: { messageId: messageId, labelId: labelId } }, jid);
+    const removeMessageLabel = (jid, messageId, labelId) =>
+        chatModify({ removeMessageLabel: { messageId: messageId, labelId: labelId } }, jid);
+    const clearMessage = (jid, key, timeStamp) =>
+        chatModify(
+            {
+                delete: true,
+                lastMessages: [{ key: key, messageTimestamp: timeStamp }],
+            },
+            jid
+        );
+    const addOrEditQuickReply = (quickReply) => chatModify({ quickReply: quickReply }, "");
+    const removeQuickReply = (timestamp) =>
+        chatModify({ quickReply: { timestamp: timestamp, deleted: true } }, "");
+    const executeInitQueries = async () => {
+        await Promise.all([fetchProps(), fetchBlocklist(), fetchPrivacySettings()]);
+    };
+    const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
+        ev.emit("messages.upsert", { messages: [msg], type: type });
+        if (!!msg.pushName) {
+            let jid = msg.key.fromMe
+                ? authState.creds.me.id
+                : msg.key.participant || msg.key.remoteJid;
+            jid = jidNormalizedUser(jid);
+            if (!msg.key.fromMe) {
+                ev.emit("contacts.update", [
+                    { id: jid, notify: msg.pushName, verifiedName: msg.verifiedBizName },
+                ]);
+            }
+            if (msg.key.fromMe && msg.pushName && authState.creds.me?.name !== msg.pushName) {
+                ev.emit("creds.update", {
+                    me: { ...authState.creds.me, name: msg.pushName },
+                });
+            }
+        }
+        const historyMsg = getHistoryMsg(msg.message);
+        const shouldProcessHistoryMsg = historyMsg
+            ? shouldSyncHistoryMessage(historyMsg) &&
+              PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
+            : false;
+        if (historyMsg && syncState === SyncState.AwaitingInitialSync) {
+            if (awaitingSyncTimeout) {
+                clearTimeout(awaitingSyncTimeout);
+                awaitingSyncTimeout = undefined;
+            }
+            if (shouldProcessHistoryMsg) {
+                syncState = SyncState.Syncing;
+                logger.info("Transitioned to Syncing state");
+            } else {
+                syncState = SyncState.Online;
+                logger.info(
+                    "History sync skipped, transitioning to Online state and flushing buffer"
+                );
+                ev.flush();
+            }
+        }
+        const doAppStateSync = async () => {
+            if (syncState === SyncState.Syncing) {
+                logger.info("Doing app state sync");
+                await resyncAppState(ALL_WA_PATCH_NAMES, true);
+                syncState = SyncState.Online;
+                logger.info(
+                    "App state sync complete, transitioning to Online state and flushing buffer"
+                );
+                ev.flush();
+                const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1;
+                ev.emit("creds.update", { accountSyncCounter: accountSyncCounter });
+            }
+        };
+        await Promise.all([
+            (async () => {
+                if (shouldProcessHistoryMsg) {
+                    await doAppStateSync();
+                }
+            })(),
+            processMessage(msg, {
+                signalRepository: signalRepository,
+                shouldProcessHistoryMsg: shouldProcessHistoryMsg,
+                placeholderResendCache: placeholderResendCache,
+                ev: ev,
+                creds: authState.creds,
+                keyStore: authState.keys,
+                logger: logger,
+                options: config.options,
+                getMessage: getMessage,
+            }),
+        ]);
+        if (msg.message?.protocolMessage?.appStateSyncKeyShare && syncState === SyncState.Syncing) {
+            logger.info("App state sync key arrived, triggering app state sync");
+            await doAppStateSync();
+        }
+    });
+    ws.on("CB:presence", handlePresenceUpdate);
+    ws.on("CB:chatstate", handlePresenceUpdate);
+    ws.on("CB:ib,,dirty", async (node) => {
+        const { attrs: attrs } = getBinaryNodeChild(node, "dirty");
+        const type = attrs.type;
+        switch (type) {
+            case "account_sync":
+                if (attrs.timestamp) {
+                    let { lastAccountSyncTimestamp: lastAccountSyncTimestamp } = authState.creds;
+                    if (lastAccountSyncTimestamp) {
+                        await cleanDirtyBits("account_sync", lastAccountSyncTimestamp);
+                    }
+                    lastAccountSyncTimestamp = +attrs.timestamp;
+                    ev.emit("creds.update", {
+                        lastAccountSyncTimestamp: lastAccountSyncTimestamp,
+                    });
+                }
+                break;
+            case "groups":
+                break;
+            default:
+                logger.info({ node: node }, "received unknown sync");
+                break;
+        }
+    });
+    ev.on(
+        "connection.update",
+        ({
+            connection: connection,
+            receivedPendingNotifications: receivedPendingNotifications,
+        }) => {
+            if (connection === "open") {
+                if (fireInitQueries) {
+                    executeInitQueries().catch((error) => onUnexpectedError(error, "init queries"));
+                }
+                sendPresenceUpdate(markOnlineOnConnect ? "available" : "unavailable").catch(
+                    (error) => onUnexpectedError(error, "presence update requests")
+                );
+            }
+            if (!receivedPendingNotifications || syncState !== SyncState.Connecting) {
+                return;
+            }
+            syncState = SyncState.AwaitingInitialSync;
+            logger.info("Connection is now AwaitingInitialSync, buffering events");
+            ev.buffer();
+            const willSyncHistory = shouldSyncHistoryMessage(
+                proto.Message.HistorySyncNotification.create({
+                    syncType: proto.HistorySync.HistorySyncType.RECENT,
+                })
+            );
+            if (!willSyncHistory) {
+                logger.info(
+                    "History sync is disabled by config, not waiting for notification. Transitioning to Online."
+                );
+                syncState = SyncState.Online;
+                setTimeout(() => ev.flush(), 0);
+                return;
+            }
+            logger.info("History sync is enabled, awaiting notification with a 20s timeout.");
+            if (awaitingSyncTimeout) {
+                clearTimeout(awaitingSyncTimeout);
+            }
+            awaitingSyncTimeout = setTimeout(() => {
+                if (syncState === SyncState.AwaitingInitialSync) {
+                    logger.warn(
+                        "Timeout in AwaitingInitialSync, forcing state to Online and flushing buffer"
+                    );
+                    syncState = SyncState.Online;
+                    ev.flush();
+                }
+            }, 2e4);
+        }
+    );
+    return {
+        ...conn,
+        star: star,
+        addOrEditContact: addOrEditContact,
+        removeContact: removeContact,
+        fetchPrivacySettings: fetchPrivacySettings,
+        upsertMessage: upsertMessage,
+        appPatch: appPatch,
+        createCallLink: createCallLink,
+        sendPresenceUpdate: sendPresenceUpdate,
+        presenceSubscribe: presenceSubscribe,
+        getBotListV2: getBotListV2,
+        messageMutex: messageMutex,
+        receiptMutex: receiptMutex,
+        appStatePatchMutex: appStatePatchMutex,
+        notificationMutex: notificationMutex,
+        getLidUser: getLidUser,
+        fetchBlocklist: fetchBlocklist,
+        fetchStatus: fetchStatus,
+        fetchDisappearingDuration: fetchDisappearingDuration,
+        updateProfilePicture: updateProfilePicture,
+        removeProfilePicture: removeProfilePicture,
+        updateProfileStatus: updateProfileStatus,
+        updateProfileName: updateProfileName,
+        updateBlockStatus: updateBlockStatus,
+        updateCallPrivacy: updateCallPrivacy,
+        updateMessagesPrivacy: updateMessagesPrivacy,
+        updateLastSeenPrivacy: updateLastSeenPrivacy,
+        updateOnlinePrivacy: updateOnlinePrivacy,
+        updateProfilePicturePrivacy: updateProfilePicturePrivacy,
+        updateStatusPrivacy: updateStatusPrivacy,
+        updateReadReceiptsPrivacy: updateReadReceiptsPrivacy,
+        updateGroupsAddPrivacy: updateGroupsAddPrivacy,
+        updateDefaultDisappearingMode: updateDefaultDisappearingMode,
+        updateDisableLinkPreviewsPrivacy: updateDisableLinkPreviewsPrivacy,
+        getBusinessProfile: getBusinessProfile,
+        resyncAppState: resyncAppState,
+        chatModify: chatModify,
+        cleanDirtyBits: cleanDirtyBits,
+        addLabel: addLabel,
+        addChatLabel: addChatLabel,
+        removeChatLabel: removeChatLabel,
+        addMessageLabel: addMessageLabel,
+        removeMessageLabel: removeMessageLabel,
+        clearMessage: clearMessage,
+        addOrEditQuickReply: addOrEditQuickReply,
+        removeQuickReply: removeQuickReply,
+    };
+};
+module.exports = { makeChatsSocket: makeChatsSocket };