@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/cjs/crypto/zdb-cipher.cjs

@@ -0,0 +1,177 @@
+'use strict';
+
+var crypto = require('node:crypto');
+var protocol = require('../constants/protocol.cjs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+
+/**
+ * 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
+ */
+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).
+ */
+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.ZaloApiError("Invalid RSA PKCS#1 v1.5 padding");
+    const sep = em.indexOf(0x00, 2);
+    if (sep < 10)
+        throw new ZaloApiError.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`.
+ */
+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?.code || "");
+        const msg = String(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.
+ */
+function deriveZdbAesKey(decryptedRsaBytes) {
+    const upperHex = decryptedRsaBytes.toString("hex").toUpperCase();
+    if (upperHex.length < protocol.ZALO_PROTOCOL.AES_256_KEY_BYTE_LENGTH) {
+        throw new ZaloApiError.ZaloApiError(`Decrypted RSA key hex is too short (${upperHex.length} chars, expected >= 32)`);
+    }
+    return Buffer.from(upperHex.slice(0, protocol.ZALO_PROTOCOL.AES_256_KEY_BYTE_LENGTH), "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`).
+ */
+function decryptZdbBuffer(zdbBuffer, aesKey) {
+    const ZDB_MAGIC = Buffer.from(protocol.ZALO_PROTOCOL.ZDB_MAGIC_HEADER, "ascii");
+    const CHUNK_SIZE = protocol.ZALO_PROTOCOL.ZDB_CHUNK_SIZE;
+    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.ZaloApiError("Invalid AES key or buffer is not in ZDB4.0 format");
+}
+/**
+ * Parses the Table of Contents (TOC) from a decrypted ZDB4.0 container buffer,
+ * returning the list of SQLite `.db` files (`<uid>.db` / `group_<gid>.db`) and the byte offset where the XZ stream starts.
+ */
+function parseZdbHeader(zdbPlaintext) {
+    const ZDB_MAGIC = Buffer.from(protocol.ZALO_PROTOCOL.ZDB_MAGIC_HEADER, "ascii");
+    const COUNT_OFFSET = 14;
+    if (zdbPlaintext.length < COUNT_OFFSET + 4 || !zdbPlaintext.subarray(0, ZDB_MAGIC.length).equals(ZDB_MAGIC)) {
+        throw new ZaloApiError.ZaloApiError("Buffer is not a valid decrypted ZDB4.0 container");
+    }
+    const count = zdbPlaintext.readUInt32BE(COUNT_OFFSET);
+    let offset = COUNT_OFFSET + 4;
+    const entries = [];
+    for (let i = 0; i < count; i++) {
+        if (offset + 4 > zdbPlaintext.length) {
+            throw new ZaloApiError.ZaloApiError("Truncated ZDB4.0 header while reading entry name length");
+        }
+        const nameLen = zdbPlaintext.readUInt32BE(offset);
+        if (offset + 4 + nameLen + 4 > zdbPlaintext.length) {
+            throw new ZaloApiError.ZaloApiError("Truncated ZDB4.0 header while reading entry metadata");
+        }
+        const name = zdbPlaintext
+            .toString("utf8", offset + 4, offset + 4 + nameLen)
+            .replace(/\0+$/, "");
+        const size = zdbPlaintext.readUInt32BE(offset + 4 + nameLen);
+        entries.push({ name, size });
+        offset += 4 + nameLen + 4;
+    }
+    return { entries, xzOffset: offset };
+}
+
+exports.decryptWithPrivateKey = decryptWithPrivateKey;
+exports.decryptZdbBuffer = decryptZdbBuffer;
+exports.deriveZdbAesKey = deriveZdbAesKey;
+exports.generateRSAKeyPair = generateRSAKeyPair;
+exports.parseZdbHeader = parseZdbHeader;
+exports.rsaDecryptPkcs1Manual = rsaDecryptPkcs1Manual;

package/dist/cjs/index.cjs

@@ -22,19 +22,37 @@ var ZBusiness = require('./models/ZBusiness.cjs');
 var ClearUnread = require('./models/ClearUnread.cjs');
 var SyncEvent = require('./models/SyncEvent.cjs');
 var CallEvent = require('./models/CallEvent.cjs');
+var protocol = require('./constants/protocol.cjs');
+var domains = require('./constants/domains.cjs');
+var defaults = require('./constants/defaults.cjs');
+var endpoints = require('./constants/endpoints.cjs');
+var aes = require('./crypto/aes.cjs');
+var zcloudCipher = require('./crypto/zcloud-cipher.cjs');
+var zdbCipher = require('./crypto/zdb-cipher.cjs');
+var wsCipher = require('./crypto/ws-cipher.cjs');
+var serviceRouter = require('./core/service-router.cjs');
+var zcloudClient = require('./core/zcloud-client.cjs');
 var zalo = require('./zalo.cjs');
-var listen = require('./apis/listen.cjs');
+var types = require('./realtime/types.cjs');
+require('events');
+require('ws');
+require('crypto-js');
+require('node:crypto');
+require('node:fs');
+require('node:path');
+require('spark-md5');
+require('tough-cookie');
+require('./context.cjs');
 var loginQR = require('./apis/loginQR.cjs');
-var getFriendRecommendations = require('./apis/getFriendRecommendations.cjs');
-var reviewPendingMemberRequest = require('./apis/reviewPendingMemberRequest.cjs');
-var sendMessage = require('./apis/sendMessage.cjs');
-var sendReport = require('./apis/sendReport.cjs');
-var setMute = require('./apis/setMute.cjs');
-var updateAutoDeleteChat = require('./apis/updateAutoDeleteChat.cjs');
-var updateLang = require('./apis/updateLang.cjs');
-var updateSettings = require('./apis/updateSettings.cjs');
-var sendVoiceCall = require('./apis/sendVoiceCall.cjs');
-var utils = require('./utils.cjs');
+var getFriendRecommendations = require('./apis/friend/getFriendRecommendations.cjs');
+var reviewPendingMemberRequest = require('./apis/group/reviewPendingMemberRequest.cjs');
+var sendMessage = require('./apis/chat/sendMessage.cjs');
+var sendReport = require('./apis/chat/sendReport.cjs');
+var setMute = require('./apis/chat/setMute.cjs');
+var updateAutoDeleteChat = require('./apis/chat/updateAutoDeleteChat.cjs');
+var updateLang = require('./apis/auth/updateLang.cjs');
+var updateSettings = require('./apis/profile/updateSettings.cjs');
+var sendVoiceCall = require('./apis/call/sendVoiceCall.cjs');
 var apis = require('./apis.cjs');
 
 
@@ -123,10 +141,35 @@ Object.defineProperty(exports, "CallEventType", {
 	get: function () { return CallEvent.CallEventType; }
 });
 exports.initializeCallEvent = CallEvent.initializeCallEvent;
+exports.ZALO_PROTOCOL = protocol.ZALO_PROTOCOL;
+exports.ZALO_DOMAINS = domains.ZALO_DOMAINS;
+exports.ZALO_DEFAULTS = defaults.ZALO_DEFAULTS;
+exports.ZALO_ENDPOINTS = endpoints.ZALO_ENDPOINTS;
+exports.ParamsEncryptor = aes.ParamsEncryptor;
+exports.decodeAES = aes.decodeAES;
+exports.decryptResp = aes.decryptResp;
+exports.encodeAES = aes.encodeAES;
+exports.encryptPin = aes.encryptPin;
+exports.validatePin = aes.validatePin;
+exports.decryptZCloudAES = zcloudCipher.decryptZCloudAES;
+exports.encryptZCloudAES = zcloudCipher.encryptZCloudAES;
+exports.decryptWithPrivateKey = zdbCipher.decryptWithPrivateKey;
+exports.decryptZdbBuffer = zdbCipher.decryptZdbBuffer;
+exports.deriveZdbAesKey = zdbCipher.deriveZdbAesKey;
+exports.generateRSAKeyPair = zdbCipher.generateRSAKeyPair;
+exports.parseZdbHeader = zdbCipher.parseZdbHeader;
+exports.rsaDecryptPkcs1Manual = zdbCipher.rsaDecryptPkcs1Manual;
+exports.decodeBase64ToBuffer = wsCipher.decodeBase64ToBuffer;
+exports.decodeEventData = wsCipher.decodeEventData;
+exports.decodeUnit8Array = wsCipher.decodeUnit8Array;
+exports.getServiceEndpoint = serviceRouter.getServiceEndpoint;
+exports.getServiceEndpoints = serviceRouter.getServiceEndpoints;
+exports.requestZCloudDecrypted = zcloudClient.requestZCloudDecrypted;
+exports.requestZFamilyDecrypted = zcloudClient.requestZFamilyDecrypted;
 exports.Zalo = zalo.Zalo;
 Object.defineProperty(exports, "CloseReason", {
 	enumerable: true,
-	get: function () { return listen.CloseReason; }
+	get: function () { return types.CloseReason; }
 });
 Object.defineProperty(exports, "LoginQRCallbackEventType", {
 	enumerable: true,
@@ -176,9 +219,4 @@ Object.defineProperty(exports, "CallType", {
 	enumerable: true,
 	get: function () { return sendVoiceCall.CallType; }
 });
-exports.decryptWithPrivateKey = utils.decryptWithPrivateKey;
-exports.decryptZdbBuffer = utils.decryptZdbBuffer;
-exports.deriveZdbAesKey = utils.deriveZdbAesKey;
-exports.generateRSAKeyPair = utils.generateRSAKeyPair;
-exports.parseZdbHeader = utils.parseZdbHeader;
 exports.API = apis.API;

package/dist/cjs/models/ClearUnread.cjs

@@ -3,6 +3,13 @@
 var Enum = require('./Enum.cjs');
 
 class ClearUnread {
+    idTo;
+    userName;
+    lastMsgId;
+    isGroup;
+    threadType;
+    ts;
+    type;
     constructor(data) {
         this.idTo = data.idTo;
         this.userName = data.userName;

package/dist/cjs/models/DeliveredMessage.cjs

@@ -3,16 +3,22 @@
 var Enum = require('./Enum.cjs');
 
 class UserDeliveredMessage {
+    type = Enum.ThreadType.User;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = Enum.ThreadType.User;
         this.data = data;
         this.threadId = data.deliveredUids[0];
         this.isSelf = false;
     }
 }
 class GroupDeliveredMessage {
+    type = Enum.ThreadType.Group;
+    data;
+    threadId;
+    isSelf;
     constructor(uid, data) {
-        this.type = Enum.ThreadType.Group;
         this.data = data;
         this.threadId = data.groupId;
         this.isSelf = data.deliveredUids.includes(uid);

package/dist/cjs/models/GroupEvent.cjs

@@ -27,7 +27,6 @@ exports.GroupEventType = void 0;
     GroupEventType["UNKNOWN"] = "unknown";
 })(exports.GroupEventType || (exports.GroupEventType = {}));
 function initializeGroupEvent(uid, data, type, act) {
-    var _a;
     const threadId = "group_id" in data ? data.group_id : data.groupId;
     if (type == exports.GroupEventType.JOIN_REQUEST) {
         return { type, act, data: data, threadId, isSelf: false };
@@ -86,7 +85,7 @@ function initializeGroupEvent(uid, data, type, act) {
             act,
             data: baseData,
             threadId,
-            isSelf: ((_a = baseData.updateMembers) === null || _a === void 0 ? void 0 : _a.some((member) => member.id == uid)) || baseData.sourceId == uid,
+            isSelf: baseData.updateMembers?.some((member) => member.id == uid) || baseData.sourceId == uid,
         };
     }
 }

package/dist/cjs/models/Message.cjs

@@ -3,8 +3,14 @@
 var Enum = require('./Enum.cjs');
 
 class UserMessage {
+    type = Enum.ThreadType.User;
+    data;
+    threadId;
+    /**
+     * true if the message is sent by the logged in account
+     */
+    isSelf;
     constructor(uid, data) {
-        this.type = Enum.ThreadType.User;
         this.data = data;
         this.threadId = data.uidFrom == "0" ? data.idTo : data.uidFrom;
         this.isSelf = data.uidFrom == "0";
@@ -18,8 +24,14 @@ class UserMessage {
     }
 }
 class GroupMessage {
+    type = Enum.ThreadType.Group;
+    data;
+    threadId;
+    /**
+     * true if the message is sent by the logged in account
+     */
+    isSelf;
     constructor(uid, data) {
-        this.type = Enum.ThreadType.Group;
         this.data = data;
         this.threadId = data.idTo;
         this.isSelf = data.uidFrom == "0";

package/dist/cjs/models/Reaction.cjs

@@ -59,6 +59,10 @@ exports.Reactions = void 0;
     Reactions["NONE"] = "";
 })(exports.Reactions || (exports.Reactions = {}));
 class Reaction {
+    data;
+    threadId;
+    isSelf;
+    isGroup;
     constructor(uid, data, isGroup) {
         this.data = data;
         this.threadId = isGroup || data.uidFrom == "0" ? data.idTo : data.uidFrom;

package/dist/cjs/models/SeenMessage.cjs

@@ -3,16 +3,22 @@
 var Enum = require('./Enum.cjs');
 
 class UserSeenMessage {
+    type = Enum.ThreadType.User;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = Enum.ThreadType.User;
         this.data = data;
         this.threadId = data.idTo;
         this.isSelf = false;
     }
 }
 class GroupSeenMessage {
+    type = Enum.ThreadType.Group;
+    data;
+    threadId;
+    isSelf;
     constructor(uid, data) {
-        this.type = Enum.ThreadType.Group;
         this.data = data;
         this.threadId = data.groupId;
         this.isSelf = data.seenUids.includes(uid);

package/dist/cjs/models/Typing.cjs

@@ -3,16 +3,22 @@
 var Enum = require('./Enum.cjs');
 
 class UserTyping {
+    type = Enum.ThreadType.User;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = Enum.ThreadType.User;
         this.data = data;
         this.threadId = data.uid;
         this.isSelf = false;
     }
 }
 class GroupTyping {
+    type = Enum.ThreadType.Group;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = Enum.ThreadType.Group;
         this.data = data;
         this.threadId = data.gid;
         this.isSelf = false;

package/dist/cjs/models/Undo.cjs

@@ -1,6 +1,10 @@
 'use strict';
 
 class Undo {
+    data;
+    threadId;
+    isSelf;
+    isGroup;
     constructor(uid, data, isGroup) {
         this.data = data;
         this.threadId = isGroup || data.uidFrom == "0" ? data.idTo : data.uidFrom;

package/dist/cjs/realtime/handlers/control.handler.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+var CallEvent = require('../../models/CallEvent.cjs');
+var FriendEvent = require('../../models/FriendEvent.cjs');
+var GroupEvent = require('../../models/GroupEvent.cjs');
+var SyncEvent = require('../../models/SyncEvent.cjs');
+var utils = require('../../utils.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+async function handleRealtimeControlPacket(listener, ctx, selfListen, version, cmd, subCmd, parsed, cipherKey) {
+    if (version == 1 && cmd == 601 && subCmd == 0) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { controls } = parsedData;
+        for (const control of controls) {
+            if (control.content.act_type == "file_done") {
+                const data = {
+                    fileUrl: control.content.data.url,
+                    fileId: control.content.fileId,
+                };
+                const uploadCallback = ctx.uploadCallbacks.get(String(control.content.fileId));
+                if (uploadCallback)
+                    uploadCallback(data);
+                ctx.uploadCallbacks.delete(String(control.content.fileId));
+                listener.emit("upload_attachment", data);
+            }
+            else if (control.content.act_type == "group") {
+                if (control.content.act == "join_reject")
+                    continue;
+                const groupEventData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                const groupEvent = GroupEvent.initializeGroupEvent(ctx.uid, groupEventData, utils.getGroupEventType(control.content.act), control.content.act);
+                if (groupEvent.isSelf && !selfListen)
+                    continue;
+                listener.emit("group_event", groupEvent);
+            }
+            else if (control.content.act_type == "fr") {
+                if (control.content.act == "req")
+                    continue;
+                const friendEventData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                if (typeof friendEventData == "object" &&
+                    "topic" in friendEventData &&
+                    typeof friendEventData.topic == "object" &&
+                    "params" in friendEventData.topic) {
+                    friendEventData.topic.params = JSON.parse(`${friendEventData.topic.params}`);
+                }
+                const friendEvent = FriendEvent.initializeFriendEvent(ctx.uid, typeof friendEventData == "number" ? control.content.data : friendEventData, utils.getFriendEventType(control.content.act));
+                if (friendEvent.isSelf && !selfListen)
+                    continue;
+                listener.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 = SyncEvent.initializeSyncEvent(syncEventData, control.content.act, control.content.act_type);
+                listener.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 = CallEvent.initializeCallEvent(callEventData, control.content.act, control.content.act_type);
+                listener.emit("call_event", callEvent);
+            }
+            else if (control.content.act_type == "voice2text") {
+                const v2tData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                listener.emit("voice2text_event", {
+                    act: control.content.act,
+                    act_type: "voice2text",
+                    data: v2tData,
+                });
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+exports.handleRealtimeControlPacket = handleRealtimeControlPacket;

package/dist/cjs/realtime/handlers/message.handler.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+require('../../models/AutoReply.cjs');
+require('../../models/Bank.cjs');
+require('../../models/Board.cjs');
+var Enum = require('../../models/Enum.cjs');
+require('../../models/FriendEvent.cjs');
+require('../../models/Group.cjs');
+require('../../models/GroupEvent.cjs');
+var Message = require('../../models/Message.cjs');
+require('../../models/Reaction.cjs');
+require('../../models/Reminder.cjs');
+var Undo = require('../../models/Undo.cjs');
+require('../../models/ZBusiness.cjs');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+var utils = require('../../utils.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+async function handleRealtimeMessagePacket(listener, ctx, selfListen, onMessageCallback, version, cmd, subCmd, parsed, cipherKey) {
+    if (version == 1 && [501, 551].includes(cmd) && subCmd == 0) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { msgs } = parsedData;
+        for (const msg of msgs) {
+            if (typeof msg.content == "object" && utils.hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo.Undo(ctx.uid, msg, false);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                const messageObject = new Message.UserMessage(ctx.uid, msg);
+                if (messageObject.isSelf && !selfListen)
+                    continue;
+                onMessageCallback(messageObject);
+                listener.emit("message", messageObject);
+            }
+        }
+        return true;
+    }
+    if (version == 1 && cmd == 521 && subCmd == 0) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { groupMsgs } = parsedData;
+        for (const msg of groupMsgs) {
+            if (typeof msg.content == "object" && utils.hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo.Undo(ctx.uid, msg, true);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                const messageObject = new Message.GroupMessage(ctx.uid, msg);
+                if (messageObject.isSelf && !selfListen)
+                    continue;
+                onMessageCallback(messageObject);
+                listener.emit("message", messageObject);
+            }
+        }
+        return true;
+    }
+    if (cmd == 510 && (subCmd == 0 || subCmd == 1)) {
+        const decoded = await wsCipher.decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data ?? decoded;
+        const msgs = (parsedData?.msgs ?? []);
+        const responseMsgs = [];
+        for (const msg of msgs) {
+            if (typeof msg.content == "object" && utils.hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo.Undo(ctx.uid, msg, false);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                responseMsgs.push(new Message.UserMessage(ctx.uid, msg));
+            }
+        }
+        if (responseMsgs.length > 0 || msgs.length === 0) {
+            listener.emit("old_messages", responseMsgs, Enum.ThreadType.User, parsedData?.more === 1);
+        }
+        return true;
+    }
+    if (cmd == 511 && (subCmd == 0 || subCmd == 1)) {
+        const decoded = await wsCipher.decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data ?? decoded;
+        const groupMsgs = (parsedData?.groupMsgs ?? []);
+        const responseMsgs = [];
+        for (const msg of groupMsgs) {
+            if (typeof msg.content == "object" && utils.hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo.Undo(ctx.uid, msg, true);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                responseMsgs.push(new Message.GroupMessage(ctx.uid, msg));
+            }
+        }
+        if (responseMsgs.length > 0 || groupMsgs.length === 0) {
+            listener.emit("old_messages", responseMsgs, Enum.ThreadType.Group, parsedData?.more === 1);
+        }
+        return true;
+    }
+    return false;
+}
+
+exports.handleRealtimeMessagePacket = handleRealtimeMessagePacket;