@softtynet/zca-js 2.2.1 → 2.2.2

package/dist/models/SyncEvent.js

@@ -0,0 +1,50 @@
+export var SyncEventType;
+(function (SyncEventType) {
+    SyncEventType["USER_CONFIRM"] = "user_confirm";
+    SyncEventType["SYNCMSG_INFO"] = "syncmsg_info";
+    SyncEventType["TRANSFER_ERROR"] = "transfer_error";
+    SyncEventType["TRANSFER_AFTER_LOGIN"] = "transfer_after_login";
+    SyncEventType["UNKNOWN"] = "unknown";
+})(SyncEventType || (SyncEventType = {}));
+export function initializeSyncEvent(data, act, act_type) {
+    if (act === "user_confirm") {
+        return {
+            type: SyncEventType.USER_CONFIRM,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else if (act === "syncmsg_info") {
+        return {
+            type: SyncEventType.SYNCMSG_INFO,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else if (act === "transfer_error") {
+        return {
+            type: SyncEventType.TRANSFER_ERROR,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else if (act === "transfer_after_login") {
+        return {
+            type: SyncEventType.TRANSFER_AFTER_LOGIN,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else {
+        return {
+            type: SyncEventType.UNKNOWN,
+            data,
+            act,
+            act_type,
+        };
+    }
+}

package/dist/models/index.d.ts

@@ -20,3 +20,7 @@ export * from "./User.js";
 export * from "./ZBusiness.js";
 export * from "./Label.js";
 export * from "./Sticker.js";
+export * from "./ClearUnread.js";
+export * from "./SyncEvent.js";
+export * from "./SyncData.js";
+export * from "./CallEvent.js";

package/dist/models/index.js

@@ -20,3 +20,7 @@ export * from "./User.js";
 export * from "./ZBusiness.js";
 export * from "./Label.js";
 export * from "./Sticker.js";
+export * from "./ClearUnread.js";
+export * from "./SyncEvent.js";
+export * from "./SyncData.js";
+export * from "./CallEvent.js";

package/dist/utils.d.ts

@@ -209,4 +209,38 @@ export declare function hexToNegativeColor(hex: string): number;
  */
 export declare function negativeColorToHex(negativeColor: number): string;
 export declare function normalizeHolderName(input?: string): string | undefined;
+/**
+ * Generates an RSA 2048-bit key pair for mobile message synchronization (`pull_mobile_msg`)
+ * @returns Object containing public and private keys in both PEM and Base64 formats
+ */
+export declare function generateRSAKeyPair(): {
+    publicKeyBase64: string;
+    privateKeyBase64: string;
+    publicKey: string;
+    privateKey: string;
+};
+/**
+ * Pure-BigInt RSA CRT PKCS#1 v1.5 decryption fallback for Node.js environments
+ * where OpenSSL blocks `RSA_PKCS1_PADDING` in `crypto.privateDecrypt` (CVE-2023-46809).
+ */
+export declare function rsaDecryptPkcs1Manual(privateKeyPem: string, cipher: Buffer): Buffer;
+/**
+ * Decrypt `encrypted_key` from `syncmsg_info` using RSA private key with PKCS#1 v1.5 scheme.
+ * Automatically falls back to pure-BigInt CRT decryption if OpenSSL disables `RSA_PKCS1_PADDING`.
+ *
+ * @param privateKey - RSA private key in PEM format
+ * @param encryptedBase64 - Base64 encoded `encrypted_key` from `syncmsg_info`
+ * @returns Raw decrypted bytes (typically 16-32 bytes; use `deriveZdbAesKey` for ZDB4.0 AES-256-CBC key)
+ */
+export declare function decryptWithPrivateKey(privateKey: string, encryptedBase64: string): Buffer;
+/**
+ * Derives the 32-byte AES-256-CBC key for Zalo ZDB4.0 (`.db.crypt`) backup files
+ * from the raw RSA-decrypted bytes: first 32 uppercase hex characters as ASCII bytes.
+ */
+export declare function deriveZdbAesKey(decryptedRsaBytes: Buffer): Buffer;
+/**
+ * Decrypts a Zalo ZDB4.0 (`.db.crypt`) backup buffer into its plaintext ZDB4.0 container
+ * (header + table of contents + XZ stream) using 64KB independent AES-256-CBC chunks (`IV = 0`).
+ */
+export declare function decryptZdbBuffer(zdbBuffer: Buffer, aesKey: Buffer): Buffer;
 export {};

package/dist/utils.js

@@ -679,7 +679,16 @@ export async function handleZaloResponse(ctx, response, isEncrypted = true) {
             };
             return result;
         }
-        const decodedData = isEncrypted ? JSON.parse(decodeAES(ctx.secretKey, jsonData.data)) : jsonData;
+        if (isEncrypted && (!jsonData.data || jsonData.data.length === 0)) {
+            result.data = {};
+            return result;
+        }
+        const decodedStr = isEncrypted ? decodeAES(ctx.secretKey, jsonData.data) : null;
+        if (isEncrypted && (!decodedStr || decodedStr.length === 0)) {
+            result.data = {};
+            return result;
+        }
+        const decodedData = isEncrypted ? JSON.parse(decodedStr) : jsonData;
         if (decodedData.error_code != 0) {
             result.error = {
                 message: decodedData.error_message,
@@ -804,3 +813,141 @@ export function normalizeHolderName(input) {
         .trim();
     return normalized.length >= 5 ? normalized : undefined;
 }
+/**
+ * Generates an RSA 2048-bit key pair for mobile message synchronization (`pull_mobile_msg`)
+ * @returns Object containing public and private keys in both PEM and Base64 formats
+ */
+export function generateRSAKeyPair() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
+        modulusLength: 2048,
+        publicKeyEncoding: { type: "spki", format: "pem" },
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+    });
+    const publicKeyBase64 = publicKey
+        .toString()
+        .replace(/-----BEGIN PUBLIC KEY-----/g, "")
+        .replace(/-----END PUBLIC KEY-----/g, "")
+        .replace(/\s+/g, "");
+    const privateKeyBase64 = privateKey
+        .toString()
+        .replace(/-----BEGIN PRIVATE KEY-----/g, "")
+        .replace(/-----END PRIVATE KEY-----/g, "")
+        .replace(/\s+/g, "");
+    return { publicKeyBase64, privateKeyBase64, publicKey: publicKey.toString(), privateKey: privateKey.toString() };
+}
+function b64urlToBigInt(value) {
+    return BigInt("0x" + Buffer.from(value, "base64url").toString("hex"));
+}
+function modPow(base, exp, mod) {
+    const zero = BigInt(0);
+    const one = BigInt(1);
+    let result = one;
+    base %= mod;
+    while (exp > zero) {
+        if (exp & one)
+            result = (result * base) % mod;
+        base = (base * base) % mod;
+        exp >>= one;
+    }
+    return result;
+}
+/**
+ * Pure-BigInt RSA CRT PKCS#1 v1.5 decryption fallback for Node.js environments
+ * where OpenSSL blocks `RSA_PKCS1_PADDING` in `crypto.privateDecrypt` (CVE-2023-46809).
+ */
+export function rsaDecryptPkcs1Manual(privateKeyPem, cipher) {
+    const jwk = crypto.createPrivateKey(privateKeyPem).export({ format: "jwk" });
+    const n = b64urlToBigInt(jwk.n);
+    const p = b64urlToBigInt(jwk.p);
+    const q = b64urlToBigInt(jwk.q);
+    const dp = b64urlToBigInt(jwk.dp);
+    const dq = b64urlToBigInt(jwk.dq);
+    const qi = b64urlToBigInt(jwk.qi);
+    const c = BigInt("0x" + cipher.toString("hex"));
+    const m1 = modPow(c, dp, p);
+    const m2 = modPow(c, dq, q);
+    const h = (qi * (((m1 - m2) % p) + p)) % p;
+    const m = m2 + h * q;
+    const k = Math.ceil(n.toString(16).length / 2);
+    const em = Buffer.from(m.toString(16).padStart(k * 2, "0"), "hex");
+    if (em[0] !== 0x00 || em[1] !== 0x02)
+        throw new ZaloApiError("Invalid RSA PKCS#1 v1.5 padding");
+    const sep = em.indexOf(0x00, 2);
+    if (sep < 10)
+        throw new ZaloApiError("Invalid RSA PKCS#1 v1.5 padding separator");
+    return em.subarray(sep + 1);
+}
+/**
+ * Decrypt `encrypted_key` from `syncmsg_info` using RSA private key with PKCS#1 v1.5 scheme.
+ * Automatically falls back to pure-BigInt CRT decryption if OpenSSL disables `RSA_PKCS1_PADDING`.
+ *
+ * @param privateKey - RSA private key in PEM format
+ * @param encryptedBase64 - Base64 encoded `encrypted_key` from `syncmsg_info`
+ * @returns Raw decrypted bytes (typically 16-32 bytes; use `deriveZdbAesKey` for ZDB4.0 AES-256-CBC key)
+ */
+export function decryptWithPrivateKey(privateKey, encryptedBase64) {
+    const cleanKey = privateKey.replace(/\\n/g, "\n");
+    const encryptedBuffer = Buffer.from(encryptedBase64, "base64");
+    try {
+        return crypto.privateDecrypt({
+            key: cleanKey,
+            padding: crypto.constants.RSA_PKCS1_PADDING,
+        }, encryptedBuffer);
+    }
+    catch (err) {
+        const errorObj = err;
+        const code = String((errorObj === null || errorObj === void 0 ? void 0 : errorObj.code) || "");
+        const msg = String((errorObj === null || errorObj === void 0 ? void 0 : errorObj.message) || "");
+        if (code.includes("INVALID_ARG") || /RSA_PKCS1_PADDING|security-revert|not supported/i.test(msg)) {
+            return rsaDecryptPkcs1Manual(cleanKey, encryptedBuffer);
+        }
+        throw err;
+    }
+}
+/**
+ * Derives the 32-byte AES-256-CBC key for Zalo ZDB4.0 (`.db.crypt`) backup files
+ * from the raw RSA-decrypted bytes: first 32 uppercase hex characters as ASCII bytes.
+ */
+export function deriveZdbAesKey(decryptedRsaBytes) {
+    const upperHex = decryptedRsaBytes.toString("hex").toUpperCase();
+    if (upperHex.length < 32) {
+        throw new ZaloApiError(`Decrypted RSA key hex is too short (${upperHex.length} chars, expected >= 32)`);
+    }
+    return Buffer.from(upperHex.slice(0, 32), "ascii");
+}
+/**
+ * Decrypts a Zalo ZDB4.0 (`.db.crypt`) backup buffer into its plaintext ZDB4.0 container
+ * (header + table of contents + XZ stream) using 64KB independent AES-256-CBC chunks (`IV = 0`).
+ */
+export function decryptZdbBuffer(zdbBuffer, aesKey) {
+    const ZDB_MAGIC = Buffer.from("ZDB4.0", "ascii");
+    const CHUNK_SIZE = 0x10000;
+    const zeroIv = Buffer.alloc(16, 0);
+    for (const startOffset of [0, 4]) {
+        const encryptedLength = Math.floor((zdbBuffer.length - startOffset) / 16) * 16;
+        if (encryptedLength < 16)
+            continue;
+        const firstChunkLen = Math.min(CHUNK_SIZE, encryptedLength);
+        const firstDecipher = crypto.createDecipheriv("aes-256-cbc", aesKey, zeroIv);
+        firstDecipher.setAutoPadding(false);
+        const firstPlain = Buffer.concat([
+            firstDecipher.update(zdbBuffer.subarray(startOffset, startOffset + firstChunkLen)),
+            firstDecipher.final(),
+        ]);
+        if (!firstPlain.subarray(0, ZDB_MAGIC.length).equals(ZDB_MAGIC)) {
+            continue;
+        }
+        const chunks = [firstPlain];
+        for (let offset = CHUNK_SIZE; offset < encryptedLength; offset += CHUNK_SIZE) {
+            const len = Math.min(CHUNK_SIZE, encryptedLength - offset);
+            const decipher = crypto.createDecipheriv("aes-256-cbc", aesKey, zeroIv);
+            decipher.setAutoPadding(false);
+            chunks.push(Buffer.concat([
+                decipher.update(zdbBuffer.subarray(startOffset + offset, startOffset + offset + len)),
+                decipher.final(),
+            ]));
+        }
+        return Buffer.concat(chunks);
+    }
+    throw new ZaloApiError("Invalid AES key or buffer is not in ZDB4.0 format");
+}

package/docs/REA_REVERSE_ENGINEERING_PLAN.md

@@ -0,0 +1,140 @@
+# Tài Liệu & Kế Hoạch Sử Dụng REA (`morluto/rea`) Cho Dự Án `zca-js`
+
+Tài liệu này là sổ tay kỹ thuật hoàn chỉnh hướng dẫn cài đặt, vận hành bộ công cụ **REA (`rea-agents`)** ([github.com/morluto/rea](https://github.com/morluto/rea) | [rea.tools](https://rea.tools/)) và **Kế hoạch 4 giai đoạn** áp dụng REA để dịch ngược các tính năng nâng cao của Zalo Desktop (`app.asar` + Native Addons) và Zalo Web (`chat.zalo.me`).
+
+---
+
+## 1. Tổng Quan Về REA (`rea-agents`)
+
+**REA (Reverse Engineering Assistant)** là một bộ công cụ **CLI + MCP Server** chuyên dụng giúp kết nối các AI Coding Agents (như Antigravity, Claude Code, Cursor, Codex) trực tiếp với các trình dịch ngược phần mềm:
+
+| Thành phần mục tiêu | Công cụ REA sử dụng | Ứng dụng trong `zca-js` |
+| :--- | :--- | :--- |
+| **Gói Electron (`app.asar`)** | `analyze-javascript-application` | Giải nén, quét AST, trích xuất bảng `commandId`, endpoint REST/WebSocket, hằng số mã hóa từ `/Applications/Zalo.app/Contents/Resources/app.asar`. |
+| **Web App (`chat.zalo.me`)** | `analyze-website` + HAR Capture | Quét các webpack chunks, WebWorker, WASM (`libzproto_wasm_bg.wasm`) và phân tích lưu lượng mạng thực tế (`.har`). |
+| **Cơ sở dữ liệu cục bộ** | SQLite Inspector | Kiểm tra cấu trúc bảng `ChatContent`, `message`, `conversation` trong file sao lưu `ZDB4.0` (`.db.crypt`) của Zalo Mobile/PC. |
+| **Native Binary (`.node` / `.dylib`)** | Ghidra / Hopper / IDA Bridge | Dịch ngược mã máy C/C++ trong `zcall.node`, `libzrtc.dylib`, `zcrypto.node` để lấy thuật toán mã hóa media (ZRTP) và chữ ký native. |
+
+---
+
+## 2. Cài Đặt & Cấu Hình Chuẩn Bị
+
+### 2.1. Yêu cầu hệ thống
+1. **Node.js `>= 22.19.0` hoặc `24.x`** (bắt buộc vì `rea-agents` sử dụng module native `node:sqlite` để lập chỉ mục các hàm/symbol khi dịch ngược):
+   ```bash
+   # Kiểm tra phiên bản Node hiện tại
+   node -v
+
+   # Nếu đang ở Node 20, chuyển sang Node 22+ qua nvm hoặc fnm:
+   nvm install 22 && nvm use 22
+   ```
+2. **Ứng dụng Zalo Desktop trên macOS**:
+   - Đường dẫn ASAR: `/Applications/Zalo.app/Contents/Resources/app.asar`
+   - Đường dẫn Native Addons đã giải nén: `/Applications/Zalo.app/Contents/Resources/app.asar.unpacked/`
+3. **Trình dịch ngược Binary (tuỳ chọn cho Giai đoạn 1 & 3)**:
+   - **Ghidra** (miễn phí, mã nguồn mở) hoặc **Hopper Disassembler** / **IDA Pro** trên macOS.
+
+### 2.2. Cài đặt và kết nối MCP Server
+Chạy lệnh khởi tạo tự động của REA để đăng ký MCP server vào trình soạn thảo/AI Agent:
+```bash
+npx -y rea-agents@latest setup
+```
+Hoặc cấu hình thủ công trong `mcp_config.json`:
+```json
+{
+  "mcpServers": {
+    "rea": {
+      "command": "npx",
+      "args": ["-y", "rea-agents@latest", "mcp"]
+    }
+  }
+}
+```
+
+---
+
+## 3. Sổ Tay Các Lệnh REA Thực Chiến Với Zalo
+
+### 3.1. Phân tích gói Electron `app.asar` của Zalo PC
+```bash
+npx -y rea-agents@latest analyze-javascript-application \
+  "/Applications/Zalo.app/Contents/Resources/app.asar" \
+  --json
+```
+- Lệnh này giúp lập chỉ mục toàn bộ các webpack modules bên trong `app.asar` (ví dụ module chứa bảng định tuyến `commandId` từ `10001` đến `16228`, `SyncMessageController`, `BackupMsgController`, `VoiceCallDomain`, v.v.).
+
+### 3.2. Phân tích trực tiếp `chat.zalo.me`
+```bash
+npx -y rea-agents@latest analyze-website https://chat.zalo.me --json
+```
+
+### 3.3. Giải nén `app.asar` ra thư mục tạm để tra cứu sâu kết hợp REA
+Khi cần kết hợp REA với tìm kiếm mã nguồn trực tiếp:
+```bash
+npx -y @electron/asar extract \
+  "/Applications/Zalo.app/Contents/Resources/app.asar" \
+  "/tmp/zalo-asar-extracted"
+```
+
+---
+
+## 4. Hiện Trạng Các Tính Năng Đã Hoàn Thiện (100% Verified) Trong `zca-js`
+
+Trước khi dùng REA cho các tính năng mới, dưới đây là các tính năng **đã được xác minh 100% từ `app.asar` và tích hợp sẵn vào nhánh `lib` của `zca-js`**:
+
+| Nhóm tính năng | API / Sự kiện trong `zca-js` | Command ID / Giao thức Zalo | Trạng thái |
+| :--- | :--- | :--- | :--- |
+| **Lấy bù tin nhắn khi mở lại app (Offline Catch-up)** | `api.preloadConversations(threadIdLocalMsgId)` | `10053` (`/api/preloadconvers/get-last-msgs`) | ✅ Hoàn tất 100% |
+| **Kéo hàng đợi tin nhắn nhỡ qua WebSocket** | `api.listener.requestOldMessages(threadType, lastMsgId)` + sự kiện `old_messages` | WS `cmd: 510` (User) & `cmd: 511` (Group), `subCmd: 0 \| 1` | ✅ Hoàn tất 100% |
+| **Đồng bộ trạng thái đã đọc liên thiết bị** | Sự kiện `api.listener.on("unread_cleared", ...)` | WS `cmd: 504` / `524` (`clearUnreads`) | ✅ Hoàn tất 100% |
+| **Kích hoạt đồng bộ từ điện thoại (Mobile Backup Sync)** | `api.requestSyncFromPhone()`, `api.pullMobile()`, `api.cancelPullMobile()` | `12000` (`pull_mobile_msg`), `12700` (`cancel_pull_mobile_msg`) | ✅ Hoàn tất 100% |
+| **Lắng nghe tiến trình đồng bộ từ điện thoại** | Sự kiện `api.listener.on("sync_event", ...)` (`USER_CONFIRM`, `SYNCMSG_INFO`, `TRANSFER_ERROR`, `TRANSFER_AFTER_LOGIN`) | WS `cmd: 601`, `act_type: "syncmsgmb"` & `"transfer_msg"` | ✅ Hoàn tất 100% |
+| **Tải & giải mã gói sao lưu `ZDB4.0` (`.db.crypt`)** | `api.getSyncData()`, `decryptWithPrivateKey()`, `deriveZdbAesKey()`, `decryptZdbBuffer()` | RSA-2048 PKCS#1 v1.5 + AES-256-CBC 64KB chunk (`ZDB4.0`) | ✅ Hoàn tất 100% |
+| **Quy đổi UID/GID số thuần sang Noised ID 19 số** | `api.getNoisedIds({ fids, gids })` & `api.decryptGids(gids)` | `12390` (`/api/znoise`) & `12054` (`/api/gid/decrypt`) | ✅ Hoàn tất 100% |
+| **Báo hiệu Gọi Điện Thoại (Voice/Video Call Signaling)** | `api.sendVoiceCall()`, `api.cancelVoiceCall()`, `api.endVoiceCall()` + sự kiện `call_event` | `11300` (`requestcall`), `11301` (`request`), `11305` (`cancel`), `11306` (`endcall`), WS `act_type: "voip"` | ✅ Hoàn tất 100% |
+
+---
+
+## 5. Kế Hoạch 4 Giai Đoạn Sử Dụng REA Cho Các Tính Năng Chưa Có
+
+Dưới đây là lộ trình chi tiết sử dụng **REA** để nghiên cứu và mở khóa 4 nhóm tính năng phức tạp tiếp theo của Zalo:
+
+### Giai đoạn 1: Giải mã Media Plane 2 chiều (Đàm thoại âm thanh RTP/ZRTP thực sự)
+- **Vấn đề hiện tại**: `api.sendVoiceCall()` đã làm đổ chuông điện thoại người nhận và lấy về thành công `{ sessId, rtpServer, rtcpServer, zrtpKey, codec }`, đồng thời nhận được sự kiện `call_event` khi người nhận bắt máy (`CallEventType.ANSWER`). Tuy nhiên, để truyền/nhận giọng nói 2 chiều sau khi bắt máy, Zalo PC không dùng WebRTC của trình duyệt mà uỷ quyền cho native addon `zcall.node` + `libzrtc.dylib`.
+- **Mục tiêu dùng REA**:
+  1. Dùng REA kết nối với **Ghidra/Hopper** mở 2 file native trong `/Applications/Zalo.app/Contents/Resources/app.asar.unpacked/`:
+     - `zcall.node` (Bridge IPC giữa Electron JS và C++)
+     - `libzrtc.dylib` (Engine xử lý giao thức UDP RTP/RTCP + mã hóa ZRTP)
+  2. Tìm các hàm xuất (exports) liên quan đến `initCall`, `sendDataToNative`, `recvSignal` (đặc biệt khi nhận `command: 401`, `416`, `402` trong `app.asar`) và `InitZRTP`.
+  3. Xác định định dạng header gói tin UDP đầu tiên gửi tới `rtpServer` / `rtcpServer` (cách đóng gói `sessId`, `callId`, `zrtpKey` và codec Opus payload type).
+  4. Viết module `VoiceCallMediaSession` bằng `node:dgram` (UDP socket) trong `zca-js` để cho phép phát file âm thanh (`.wav`/`.opus`) vào cuộc gọi hoặc thu âm luồng thoại của đối phương.
+
+### Giai đoạn 2: Giải mã giao thức Đồng bộ thế hệ 2 (`Transfer-Sync-V2` & WebAssembly)
+- **Vấn đề hiện tại**: Ngoài luồng `pull_mobile_msg` (`12000` - `ZDB4.0`), các bản Zalo mới đang triển khai song song giao thức `/api/transfer-sync-v2/request-sync` (command `12888`) và sự kiện `act_type: "transfer_sync2"` sử dụng file WebAssembly `libzproto_wasm_bg.wasm`.
+- **Mục tiêu dùng REA**:
+  1. Dùng REA phân tích class `SyncController` và `_processSync2Ctrl` trong `app.asar` để lấy toàn bộ state machine của `transfer_sync2`.
+  2. Dùng REA + Ghidra (với plugin WASM) hoặc `wasm2wat` phân tích file `libzproto_wasm_bg.wasm` để trích xuất schema Protobuf của tham số `data` trong:
+     - `/api/transfer-sync-v2/request-sync` (`12888`)
+     - `/api/transfer-sync-v2/download`
+  3. Tích hợp bộ parser Protobuf thuần TypeScript vào `zca-js` mà không cần phụ thuộc binary WASM nặng nề.
+
+### Giai đoạn 3: Giải mã Tin nhắn Mã hóa Đầu cuối (`CHAT_E2EE`, commands `16000`–`16201`)
+- **Vấn đề hiện tại**: Khi một cuộc trò chuyện bật "Mã hóa đầu cuối (E2EE)", tin nhắn trả về nằm trong mảng `eeMsgs` (khi gọi `preloadConversations`) và sử dụng cụm endpoint `/api/e2ee/pc/message/*` (`16000`–`16201`).
+- **Mục tiêu dùng REA**:
+  1. Dùng REA quét toàn bộ các tham chiếu tới `16000`–`16201` (`getE2eeDomain()`, `deleteOneOneE2eeMessageV2`, `EntriesTransferManager`) trong `app.asar`.
+  2. Dùng REA kết nối Ghidra phân tích `zcrypto.node` để xác định cơ chế trao đổi khoá (Signal Protocol / Double Ratchet hoặc X25519 + AES-GCM của Zalo).
+  3. Bổ sung `sendE2EEMessage` và bộ giải mã tự động cho `eeMsgs` trong `listen.ts` và `preloadConversations.ts`.
+
+### Giai đoạn 4: Gọi Nhóm (`Group Voice/Video Call`, commands `12433`–`12447`)
+- **Vấn đề hiện tại**: Từ `app.asar`, chúng ta đã trích xuất được danh sách đầy đủ các API gọi nhóm:
+  - `12433`: `/api/voicecall/group/requestcall` (`{ groupId, callId, typeRequest, data, partners }`)
+  - `12434`: `/api/voicecall/group/request` (`{ calleeId, callId, callType, data, session, partners, groupId }`)
+  - `12435`: `/api/voicecall/group/adduser`
+  - `12436`: `/api/voicecall/group/answer`
+  - `12437`: `/api/voicecall/group/cancel`
+  - `12438`: `/api/voicecall/group/endcall`
+  - `12439`: `/api/voicecall/group/ringring`
+  - `12445`: `/api/voicecall/group/state`
+- **Mục tiêu dùng REA**:
+  1. Dùng tính năng phân tích HAR của REA khi thực hiện 1 cuộc gọi nhóm thực tế trên Zalo PC/Web để bắt chính xác cấu trúc chuỗi JSON bên trong trường `data` và mảng `partners`.
+  2. Sau khi có mẫu payload thực tế từ HAR, đóng gói thành các API `sendGroupVoiceCall`, `cancelGroupVoiceCall`, `endGroupVoiceCall` trong `zca-js`.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@softtynet/zca-js",
-    "version": "2.2.1",
+    "version": "2.2.2",
     "description": "Unofficial Zalo API for JavaScript",
     "main": "dist/index.js",
     "type": "module",