@softtynet/zca-js 2.2.1 → 2.2.3

package/README.md

@@ -115,44 +115,70 @@ api.listener.start();
 > [!IMPORTANT]
 > Only one web listener can run per account at a time. If you open Zalo in the browser while the listener is active, the listener will be automatically stopped.
 
-### Synchronize Messages from Mobile
+### Synchronize Messages & Offline Catch-up
 
-`zca-js` supports cross-device message synchronization from the official Zalo mobile app:
-
-#### Case 1: Auto-Sync on QR Login
-When logging in via `loginQR`, check the **"Sync message with your phone"** checkbox on your phone before confirming:
+`zca-js` supports both **offline message catch-up** (when reconnecting or restarting your app) and **full mobile backup synchronization** (`ZDB4.0`) from the Zalo mobile app:
 
+#### 1. Catch Up Missed Messages After Reconnect / Restart
 ```javascript
-import { Zalo, LoginQRCallbackEventType } from "zca-js";
+import { Zalo, ThreadType } from "zca-js";
 
-const zalo = new Zalo({ selfListen: true });
-const api = await zalo.loginQR({ qrPath: "./qr.png" });
+const preload = await api.preloadConversations();
+console.log(`Preloaded ${preload.messages.length} latest messages`);
 
-// Listen for historical messages pushed from phone
-api.listener.on("old_messages", (messages, type) => {
-    console.log(`Received ${messages.length} historical synced messages!`);
+api.listener.on("old_messages", (messages, type, hasMore) => {
+    console.log(`Received ${messages.length} queued offline messages (type=${type}, hasMore=${hasMore})`);
 });
 
-api.listener.start();
-```
+api.listener.on("cipher_key", () => {
+    api.listener.requestOldMessages(ThreadType.User);
+    api.listener.requestOldMessages(ThreadType.Group);
+});
 
-#### Case 2: Manual Trigger Sync (from existing session)
-To request message synchronization from your phone at any time:
+api.listener.start({ retryOnClose: true });
+```
 
+#### 2. Trigger Mobile Backup Sync (`pull_mobile_msg`)
 ```javascript
-api.listener.on("connected", async () => {
-    // Send sync request signal to mobile phone
-    await api.requestSyncFromPhone();
-    console.log("Please tap 'Sync now' on your phone!");
+import { SyncEventType, decryptWithPrivateKey, deriveZdbAesKey, decryptZdbBuffer } from "zca-js";
+
+let privateKey = "";
+
+api.listener.on("sync_event", async (event) => {
+    if (event.type === SyncEventType.USER_CONFIRM) {
+        console.log("User confirmed sync on phone, waiting for backup upload...");
+    } else if (event.type === SyncEventType.SYNCMSG_INFO) {
+        const res = await api.getSyncData({ ...event.data, savePath: "./sync_data" });
+        if (res.success && res.data && privateKey) {
+            const rawRsa = decryptWithPrivateKey(privateKey, res.data.encrypted_key);
+            const aesKey = deriveZdbAesKey(rawRsa);
+            console.log("Downloaded backup:", res.data.file_path, "AES key length:", aesKey.length);
+        }
+    }
 });
 
-api.listener.on("old_messages", (messages, type) => {
-    console.log(`Received ${messages.length} synced messages from phone!`);
+api.listener.on("connected", async () => {
+    const session = await api.requestSyncFromPhone();
+    privateKey = session.privateKey;
+    console.log("Please tap 'Sync now' on your phone!");
 });
 
 api.listener.start();
 ```
 
+### Voice / Video Call Signaling
+
+```javascript
+import { CallType } from "zca-js";
+
+// Ring a user's phone (Audio or Video call)
+const call = await api.sendVoiceCall("target_user_id", { callType: CallType.Audio });
+console.log("Ringing callId:", call.callId, "session:", call.sessId);
+
+// Cancel ringing or end an active call
+await api.cancelVoiceCall("target_user_id", call.callId);
+```
+
 ### Send a message
 
 ```javascript

package/dist/apis/cancelPullMobile.d.ts

@@ -0,0 +1,11 @@
+export type CancelPullMobileResponse = {
+    error_code?: number | string;
+    error_message?: string;
+    data?: string;
+    [key: string]: unknown;
+};
+export type CancelPullMobileParams = {
+    public_key: string;
+    pc_name?: string;
+};
+export declare const cancelPullMobileFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => ({ public_key, pc_name }: CancelPullMobileParams) => Promise<CancelPullMobileResponse>;

package/dist/apis/cancelPullMobile.js

@@ -0,0 +1,33 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const cancelPullMobileFactory = apiFactory()((api, ctx, utils) => {
+    const baseURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/cancel_pull_mobile_msg`);
+    /**
+     * Huỷ yêu cầu đồng bộ tin nhắn từ điện thoại đang chờ (`cancel_pull_mobile_msg`, command `12700`).
+     *
+     * @param params Tham số huỷ đồng bộ (`public_key`, `pc_name`)
+     * @throws {ZaloApiError}
+     */
+    return async function cancelPullMobile({ public_key, pc_name = "Web" }) {
+        if (!public_key)
+            throw new ZaloApiError("Missing public_key");
+        const payload = {
+            pc_name,
+            public_key,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(payload));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const serviceURL = utils.makeURL(baseURL, {
+            zpw_ver: ctx.API_VERSION,
+            zpw_type: ctx.API_TYPE,
+            params: encryptedParams,
+            nretry: 0,
+        }, false);
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/cancelVoiceCall.d.ts

@@ -0,0 +1,7 @@
+import { CallType } from "./sendVoiceCall.js";
+export type CancelVoiceCallOptions = {
+    callType?: CallType;
+    status?: number;
+};
+export type CancelVoiceCallResponse = Record<string, unknown>;
+export declare const cancelVoiceCallFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (calleeId: string, callId: number, options?: CancelVoiceCallOptions) => Promise<CancelVoiceCallResponse>;

package/dist/apis/cancelVoiceCall.js

@@ -0,0 +1,43 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const cancelVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    var _a;
+    const voiceCallService = (_a = api.zpwServiceMap.voice_call) === null || _a === void 0 ? void 0 : _a[0];
+    /**
+     * Huỷ cuộc gọi đang đổ chuông trước khi người nhận bắt máy (`/api/voicecall/cancel`, command `11305`).
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param callId ID của cuộc gọi (nhận từ `sendVoiceCall`)
+     * @param options Tuỳ chọn loại cuộc gọi (`callType`) và `status`
+     * @throws {ZaloApiError}
+     */
+    return async function cancelVoiceCall(calleeId, callId, options = {}) {
+        var _a, _b;
+        if (!calleeId)
+            throw new ZaloApiError("Missing calleeId");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const numericCalleeId = Number.isNaN(Number(calleeId)) ? calleeId : Number(calleeId);
+        const params = {
+            callerId: numericCalleeId,
+            callId,
+            callType: (_a = options.callType) !== null && _a !== void 0 ? _a : CallType.Audio,
+            status: (_b = options.status) !== null && _b !== void 0 ? _b : 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt cancelVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/cancel`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/decryptGids.d.ts

@@ -1,4 +1,5 @@
 export type DecryptGidsResponse = {
-    gids: Record<string, string>;
+    gids?: Record<string, string>;
+    [key: string]: unknown;
 };
 export declare const decryptGidsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (gids: string | string[]) => Promise<DecryptGidsResponse>;

package/dist/apis/decryptGids.js

@@ -4,6 +4,7 @@ export const decryptGidsFactory = apiFactory()((api, ctx, utils) => {
     const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/gid/decrypt`);
     /**
      * Giải mã danh sách Global ID (g_...) ẩn danh thành User ID thật
+     * (tương ứng hàm `getUidFromGlobalNoiseId` / command `12054` trên Zalo PC)
      *
      * @param gids Danh sách Global ID (hoặc 1 GID đơn lẻ)
      * @throws {ZaloApiError}
@@ -14,6 +15,7 @@ export const decryptGidsFactory = apiFactory()((api, ctx, utils) => {
         if (!Array.isArray(gids))
             gids = [gids];
         const params = {
+            globalUids: JSON.stringify(gids),
             gids,
             imei: ctx.imei,
         };

package/dist/apis/endVoiceCall.d.ts

@@ -0,0 +1,5 @@
+export type EndVoiceCallOptions = {
+    status?: number;
+};
+export type EndVoiceCallResponse = Record<string, unknown>;
+export declare const endVoiceCallFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (calleeId: string, callId: number, options?: EndVoiceCallOptions) => Promise<EndVoiceCallResponse>;

package/dist/apis/endVoiceCall.js

@@ -0,0 +1,41 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const endVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    var _a;
+    const voiceCallService = (_a = api.zpwServiceMap.voice_call) === null || _a === void 0 ? void 0 : _a[0];
+    /**
+     * Kết thúc cuộc gọi thoại / video (`/api/voicecall/endcall`, command `11306`).
+     *
+     * @param calleeId User ID của đối phương
+     * @param callId ID của cuộc gọi
+     * @param options Tuỳ chọn mã trạng thái kết thúc (`status`, mặc định `3`)
+     * @throws {ZaloApiError}
+     */
+    return async function endVoiceCall(calleeId, callId, options = {}) {
+        var _a;
+        if (!calleeId)
+            throw new ZaloApiError("Missing calleeId");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const numericCalleeId = Number.isNaN(Number(calleeId)) ? calleeId : Number(calleeId);
+        const params = {
+            uidTo: numericCalleeId,
+            callId,
+            status: (_a = options.status) !== null && _a !== void 0 ? _a : 3,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt endVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/endcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getNoisedIds.d.ts

@@ -0,0 +1,9 @@
+export type GetNoisedIdsParams = {
+    fids?: Array<string | number>;
+    gids?: Array<string | number>;
+};
+export type GetNoisedIdsResponse = {
+    fids: string[];
+    gids: string[];
+};
+export declare const getNoisedIdsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => ({ fids, gids }: GetNoisedIdsParams) => Promise<GetNoisedIdsResponse>;

package/dist/apis/getNoisedIds.js

@@ -0,0 +1,67 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+const ZWID_ZNOISE_URL = "https://zwid.api.zalo.me/api/znoise";
+function toNumericIds(ids) {
+    return ids.map((id) => Number.parseInt(String(id), 10));
+}
+function normalizeNoised(list, expected, stripGroupPrefix) {
+    const out = [];
+    const arr = Array.isArray(list) ? list : [];
+    for (let i = 0; i < expected; i++) {
+        let v = arr[i] == null ? "" : String(arr[i]);
+        if (stripGroupPrefix && v.startsWith("g"))
+            v = v.slice(1);
+        out.push(v === "0" ? "" : v);
+    }
+    return out;
+}
+export const getNoisedIdsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/znoise`);
+    /**
+     * Chuyển đổi danh sách UID cá nhân (`fids`) và GID nhóm (`gids`) dạng số thuần (từ SQLite ZDB4.0 mobile)
+     * sang định dạng Noised ID 19 chữ số dùng trên Zalo Web/PC (`getNoisedUids`, command `12390`).
+     * Tự động fallback sang `https://zwid.api.zalo.me/api/znoise` nếu profile domain trả về lỗi.
+     *
+     * @param params Danh sách `fids` và `gids`
+     * @throws {ZaloApiError}
+     */
+    return async function getNoisedIds({ fids = [], gids = [] }) {
+        const payload = {
+            fids: toNumericIds(fids),
+            gids: toNumericIds(gids),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(payload));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        try {
+            const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+                method: "GET",
+            });
+            const data = await utils.resolve(response);
+            const raw = (data !== null && data !== void 0 ? data : {});
+            return {
+                fids: normalizeNoised(raw.fids, fids.length, false),
+                gids: normalizeNoised(raw.gids, gids.length, true),
+            };
+        }
+        catch (primaryErr) {
+            try {
+                const body = new URLSearchParams({ params: encryptedParams }).toString();
+                const fallbackUrl = utils.makeURL(ZWID_ZNOISE_URL);
+                const response = await utils.request(fallbackUrl, {
+                    method: "POST",
+                    body,
+                });
+                const data = await utils.resolve(response);
+                const raw = (data !== null && data !== void 0 ? data : {});
+                return {
+                    fids: normalizeNoised(raw.fids, fids.length, false),
+                    gids: normalizeNoised(raw.gids, gids.length, true),
+                };
+            }
+            catch (_a) {
+                throw primaryErr;
+            }
+        }
+    };
+});

package/dist/apis/getSyncData.d.ts

@@ -0,0 +1,13 @@
+import type { SyncDataResponse } from "../models/index.js";
+export type GetSyncDataParams = {
+    url: string;
+    encrypted_key: string;
+    file_name: string;
+    file_size: number;
+    checksum_code: string;
+    from_seq_id: number;
+    is_full_transfer: number;
+    returnStream?: boolean;
+    savePath?: string;
+};
+export declare const getSyncDataFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => ({ url, encrypted_key, file_name, file_size, checksum_code, from_seq_id, is_full_transfer, returnStream, savePath, }: GetSyncDataParams) => Promise<SyncDataResponse>;

package/dist/apis/getSyncData.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import toughCookie from "tough-cookie";
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getSyncDataFactory = apiFactory()((api, ctx, utils) => {
+    async function downloadFileStream(url) {
+        if (!ctx.cookie)
+            ctx.cookie = new toughCookie.CookieJar();
+        const cookie = ctx.cookie;
+        const manualHeaders = {
+            "Cache-Control": "no-store, must-revalidate",
+            Pragma: "no-cache",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept-Language": "en-US",
+            "User-Agent": ctx.userAgent || "",
+            cookie: await cookie.getCookieString("https://chat.zalo.me/"),
+            Expires: "0",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "no-cors",
+            "Sec-Fetch-Site": "none",
+            Connection: "keep-alive",
+        };
+        const response = await utils.request(url, {
+            method: "GET",
+            headers: manualHeaders,
+        }, true);
+        if (!response.ok) {
+            throw new ZaloApiError(`Failed to download sync file: HTTP ${response.status}`);
+        }
+        return response;
+    }
+    async function downloadFile(url) {
+        const response = await downloadFileStream(url);
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    /**
+     * Tải xuống file sao lưu tin nhắn từ sự kiện `syncmsg_info` (`.db.crypt`, định dạng `ZDB4.0`)
+     * và lưu ra ổ đĩa hoặc trả về `ReadableStream`.
+     *
+     * @param params Thông tin file sao lưu nhận được từ `SyncEventType.SYNCMSG_INFO`
+     * @returns `Promise<SyncDataResponse>`
+     */
+    return async function getSyncData({ url, encrypted_key, file_name, file_size, checksum_code, from_seq_id, is_full_transfer, returnStream = false, savePath = "./", }) {
+        try {
+            if (returnStream) {
+                const response = await downloadFileStream(url);
+                const syncDataStream = {
+                    stream: response.body,
+                    metadata: {
+                        file_name,
+                        file_size,
+                        checksum_code,
+                        from_seq_id,
+                        is_full_transfer,
+                        encrypted_key,
+                    },
+                    response: {
+                        status: response.status,
+                        statusText: response.statusText,
+                        url: response.url,
+                        contentType: response.headers.get("content-type"),
+                        contentLength: response.headers.get("content-length"),
+                    },
+                };
+                return {
+                    success: true,
+                    stream: syncDataStream,
+                };
+            }
+            const encryptedFileData = await downloadFile(url);
+            const fileName = file_name.endsWith(".db.crypt") ? file_name : `${file_name}.db.crypt`;
+            const fullPath = path.join(savePath, fileName);
+            const dir = path.dirname(fullPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(fullPath, encryptedFileData);
+            const syncData = {
+                file_path: fullPath,
+                encrypted_key,
+                metadata: {
+                    file_name: fileName,
+                    file_size,
+                    checksum_code,
+                    from_seq_id,
+                    is_full_transfer,
+                },
+            };
+            return {
+                success: true,
+                data: syncData,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error occurred",
+            };
+        }
+    };
+});

package/dist/apis/listen.d.ts

@@ -6,6 +6,9 @@ import { Reaction, Undo, ThreadType } from "../models/index.js";
 import type { ContextSession } from "../context.js";
 import { type SeenMessage } from "../models/SeenMessage.js";
 import { type DeliveredMessage } from "../models/DeliveredMessage.js";
+import { ClearUnread } from "../models/ClearUnread.js";
+import { type SyncEvent } from "../models/SyncEvent.js";
+import { type CallEvent } from "../models/CallEvent.js";
 type UploadEventData = {
     fileUrl: string;
     fileId: string;
@@ -33,15 +36,18 @@ interface ListenerEvents {
     error: [error: unknown];
     typing: [typing: Typing];
     message: [message: Message];
-    old_messages: [messages: Message[], type: ThreadType];
+    old_messages: [messages: Message[], type: ThreadType, hasMore?: boolean];
     seen_messages: [messages: SeenMessage[]];
     delivered_messages: [messages: DeliveredMessage[]];
+    unread_cleared: [items: ClearUnread[]];
     reaction: [reaction: Reaction];
     old_reactions: [reactions: Reaction[], isGroup: boolean];
     upload_attachment: [data: UploadEventData];
     undo: [data: Undo];
     friend_event: [data: FriendEvent];
     group_event: [data: GroupEvent];
+    sync_event: [data: SyncEvent];
+    call_event: [data: CallEvent];
     cipher_key: [key: string];
     ping: [];
     pong: [];
@@ -95,9 +101,11 @@ export declare class Listener extends EventEmitter<ListenerEvents> {
     stop(): void;
     sendWs(payload: WsPayload, requireId?: boolean): void;
     /**
-     * Request old messages
+     * Request old messages from Zalo WebSocket queue (`cmd 510` for User, `cmd 511` for Group).
+     * When `lastMsgId` is `null` or omitted, defaults to `"10000000000000000"` to fetch the latest offline messages.
      *
-     * @param lastMsgId
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID (`actionId`) for pagination
      */
     requestOldMessages(threadType: ThreadType, lastMsgId?: string | null): void;
     /**

package/dist/apis/listen.js

@@ -7,6 +7,9 @@ import { decodeEventData, getBrowserLanguage, getFriendEventType, getGroupEventT
 import { ZaloApiError } from "../Errors/ZaloApiError.js";
 import { GroupSeenMessage, UserSeenMessage } from "../models/SeenMessage.js";
 import { UserDeliveredMessage, GroupDeliveredMessage } from "../models/DeliveredMessage.js";
+import { ClearUnread } from "../models/ClearUnread.js";
+import { initializeSyncEvent } from "../models/SyncEvent.js";
+import { initializeCallEvent } from "../models/CallEvent.js";
 export var CloseReason;
 (function (CloseReason) {
     CloseReason[CloseReason["ManualClosure"] = 1000] = "ManualClosure";
@@ -220,7 +223,7 @@ export class Listener extends EventEmitter {
             this.emit("error", event);
         };
         ws.onmessage = async (event) => {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             this.resetWatchdog();
             this.emit("pong"); // Pulse event to notify watchdog that socket is alive
             const { data } = event;
@@ -342,6 +345,21 @@ export class Listener extends EventEmitter {
                                 continue;
                             this.emit("friend_event", friendEvent);
                         }
+                        else if (control.content.act_type == "syncmsgmb" ||
+                            control.content.act_type == "transfer_msg") {
+                            const syncEventData = typeof control.content.data == "string"
+                                ? JSON.parse(control.content.data)
+                                : control.content.data;
+                            const syncEvent = initializeSyncEvent(syncEventData, control.content.act, control.content.act_type);
+                            this.emit("sync_event", syncEvent);
+                        }
+                        else if (control.content.act_type == "voip") {
+                            const callEventData = typeof control.content.data == "string"
+                                ? JSON.parse(control.content.data)
+                                : control.content.data;
+                            const callEvent = initializeCallEvent(callEventData, control.content.act, control.content.act_type);
+                            this.emit("call_event", callEvent);
+                        }
                     }
                 }
                 if (cmd == 612) {
@@ -369,17 +387,54 @@ export class Listener extends EventEmitter {
                     const reactionObjects = reacts.map((react) => new Reaction(this.ctx.uid, react, isGroup));
                     this.emit("old_reactions", reactionObjects, isGroup);
                 }
-                if (cmd == 510 && subCmd == 1) {
-                    const parsedData = (await decodeEventData(parsed, this.cipherKey)).data;
-                    const msgs = parsedData.msgs;
-                    const responseMsgs = msgs.map((msg) => new UserMessage(this.ctx.uid, msg));
-                    this.emit("old_messages", responseMsgs, ThreadType.User);
+                if (cmd == 510 && (subCmd == 0 || subCmd == 1)) {
+                    const decoded = await decodeEventData(parsed, this.cipherKey);
+                    const parsedData = (_d = decoded === null || decoded === void 0 ? void 0 : decoded.data) !== null && _d !== void 0 ? _d : decoded;
+                    const msgs = ((_e = parsedData === null || parsedData === void 0 ? void 0 : parsedData.msgs) !== null && _e !== void 0 ? _e : []);
+                    const responseMsgs = [];
+                    for (const msg of msgs) {
+                        if (typeof msg.content == "object" && hasOwn(msg.content, "deleteMsg")) {
+                            const undoObject = new Undo(this.ctx.uid, msg, false);
+                            if (undoObject.isSelf && !this.selfListen)
+                                continue;
+                            this.emit("undo", undoObject);
+                        }
+                        else {
+                            responseMsgs.push(new UserMessage(this.ctx.uid, msg));
+                        }
+                    }
+                    if (responseMsgs.length > 0 || msgs.length === 0) {
+                        this.emit("old_messages", responseMsgs, ThreadType.User, (parsedData === null || parsedData === void 0 ? void 0 : parsedData.more) === 1);
+                    }
                 }
-                if (cmd == 511 && subCmd == 1) {
-                    const parsedData = (await decodeEventData(parsed, this.cipherKey)).data;
-                    const groupMsgs = parsedData.groupMsgs;
-                    const responseMsgs = groupMsgs.map((msg) => new GroupMessage(this.ctx.uid, msg));
-                    this.emit("old_messages", responseMsgs, ThreadType.Group);
+                if (cmd == 511 && (subCmd == 0 || subCmd == 1)) {
+                    const decoded = await decodeEventData(parsed, this.cipherKey);
+                    const parsedData = (_f = decoded === null || decoded === void 0 ? void 0 : decoded.data) !== null && _f !== void 0 ? _f : decoded;
+                    const groupMsgs = ((_g = parsedData === null || parsedData === void 0 ? void 0 : parsedData.groupMsgs) !== null && _g !== void 0 ? _g : []);
+                    const responseMsgs = [];
+                    for (const msg of groupMsgs) {
+                        if (typeof msg.content == "object" && hasOwn(msg.content, "deleteMsg")) {
+                            const undoObject = new Undo(this.ctx.uid, msg, true);
+                            if (undoObject.isSelf && !this.selfListen)
+                                continue;
+                            this.emit("undo", undoObject);
+                        }
+                        else {
+                            responseMsgs.push(new GroupMessage(this.ctx.uid, msg));
+                        }
+                    }
+                    if (responseMsgs.length > 0 || groupMsgs.length === 0) {
+                        this.emit("old_messages", responseMsgs, ThreadType.Group, (parsedData === null || parsedData === void 0 ? void 0 : parsedData.more) === 1);
+                    }
+                }
+                if ((cmd == 504 || cmd == 524) && subCmd == 0) {
+                    const decoded = await decodeEventData(parsed, this.cipherKey);
+                    const parsedData = (_h = decoded === null || decoded === void 0 ? void 0 : decoded.data) !== null && _h !== void 0 ? _h : decoded;
+                    const clearUnreads = ((_j = parsedData === null || parsedData === void 0 ? void 0 : parsedData.clearUnreads) !== null && _j !== void 0 ? _j : []);
+                    if (Array.isArray(clearUnreads) && clearUnreads.length > 0) {
+                        const items = clearUnreads.map((item) => new ClearUnread(item));
+                        this.emit("unread_cleared", items);
+                    }
                 }
                 if (cmd == 602 && subCmd == 0) {
                     const parsedData = (await decodeEventData(parsed, this.cipherKey)).data;
@@ -475,16 +530,18 @@ export class Listener extends EventEmitter {
         }
     }
     /**
-     * Request old messages
+     * Request old messages from Zalo WebSocket queue (`cmd 510` for User, `cmd 511` for Group).
+     * When `lastMsgId` is `null` or omitted, defaults to `"10000000000000000"` to fetch the latest offline messages.
      *
-     * @param lastMsgId
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID (`actionId`) for pagination
      */
     requestOldMessages(threadType, lastMsgId = null) {
         const payload = {
             version: 1,
             cmd: threadType === ThreadType.User ? 510 : 511,
             subCmd: 1,
-            data: { first: true, lastId: lastMsgId, preIds: [] },
+            data: { first: true, lastId: lastMsgId !== null && lastMsgId !== void 0 ? lastMsgId : "10000000000000000", preIds: [] },
         };
         this.sendWs(payload);
     }