@softtynet/zca-js 2.3.4 → 2.3.5

package/dist/cjs/call-engine/ZaloSrtpSession.cjs

@@ -0,0 +1,287 @@
+'use strict';
+
+var crypto = require('node:crypto');
+var node_buffer = require('node:buffer');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+
+/**
+ * Sinh ngẫu nhiên khoá Master Key (16 bytes) + Master Salt (14 bytes) = 30 bytes,
+ * mã hoá thành chuỗi Base64 40 ký tự chuẩn `zrtc::SrtpTransport` của Zalo.
+ */
+function generateSrtpMasterKeyBase64() {
+    return crypto.randomBytes(30).toString("base64");
+}
+/**
+ * Đóng gói gói tin chuẩn WebRTC RTP (12-byte header + payload).
+ */
+function buildRtpPacket(options) {
+    const header = node_buffer.Buffer.allocUnsafe(12);
+    header.writeUInt8(0x80, 0); // Version = 2, P = 0, X = 0, CC = 0
+    const ptByte = ((options.marker ? 0x80 : 0x00) | ((options.payloadType ?? 112) & 0x7f)) & 0xff;
+    header.writeUInt8(ptByte, 1);
+    header.writeUInt16BE(options.sequenceNumber & 0xffff, 2);
+    header.writeUInt32BE(options.timestamp >>> 0, 4);
+    header.writeUInt32BE(options.ssrc >>> 0, 8);
+    return node_buffer.Buffer.concat([header, options.payload]);
+}
+/**
+ * Phân tích gói tin chuẩn WebRTC RTP (RFC 3550).
+ */
+function parseRtpPacket(packet) {
+    if (!packet || packet.length < 12) {
+        throw new ZaloApiError.ZaloApiError(`Invalid RTP packet length: ${packet?.length ?? 0}`);
+    }
+    const firstByte = packet.readUInt8(0);
+    const secondByte = packet.readUInt8(1);
+    const version = (firstByte >> 6) & 0x03;
+    const padding = ((firstByte >> 5) & 0x01) === 1;
+    const extension = ((firstByte >> 4) & 0x01) === 1;
+    const csrcCount = firstByte & 0x0f;
+    const marker = ((secondByte >> 7) & 0x01) === 1;
+    const payloadType = secondByte & 0x7f;
+    const sequenceNumber = packet.readUInt16BE(2);
+    const timestamp = packet.readUInt32BE(4);
+    const ssrc = packet.readUInt32BE(8);
+    let headerLength = 12 + csrcCount * 4;
+    if (packet.length < headerLength) {
+        throw new ZaloApiError.ZaloApiError("RTP packet shorter than CSRC header length");
+    }
+    if (extension) {
+        if (packet.length < headerLength + 4) {
+            throw new ZaloApiError.ZaloApiError("RTP packet shorter than extension header");
+        }
+        const extLenWords = packet.readUInt16BE(headerLength + 2);
+        headerLength += 4 + extLenWords * 4;
+        if (packet.length < headerLength) {
+            throw new ZaloApiError.ZaloApiError("RTP packet shorter than extension payload");
+        }
+    }
+    let payloadEnd = packet.length;
+    if (padding && packet.length > headerLength) {
+        const paddingLen = packet.readUInt8(packet.length - 1);
+        if (paddingLen > 0 && headerLength + paddingLen <= packet.length) {
+            payloadEnd = packet.length - paddingLen;
+        }
+    }
+    return {
+        version,
+        padding,
+        extension,
+        csrcCount,
+        marker,
+        payloadType,
+        sequenceNumber,
+        timestamp,
+        ssrc,
+        headerLength,
+        header: packet.subarray(0, headerLength),
+        payload: packet.subarray(headerLength, payloadEnd),
+    };
+}
+/**
+ * Thuật toán dẫn xuất khoá phiên SRTP/SRTCP theo RFC 3711 Mục 4.3.1 (AES-CM PRF).
+ */
+function deriveSrtpSessionKey(masterKey, masterSalt, label, outByteLength) {
+    const iv = node_buffer.Buffer.alloc(16, 0);
+    masterSalt.copy(iv, 0, 0, 14);
+    // label nằm tại byte thứ 7 (tức (label << 48) trong khối 112-bit salt)
+    iv[7] ^= label & 0xff;
+    const cipher = crypto.createCipheriv("aes-128-ctr", masterKey, iv);
+    const zeroBlock = node_buffer.Buffer.alloc(outByteLength, 0);
+    return node_buffer.Buffer.concat([cipher.update(zeroBlock), cipher.final()]).subarray(0, outByteLength);
+}
+function buildSrtpCtrIv(sessionSalt, ssrc, roc, seqNum) {
+    const iv = node_buffer.Buffer.alloc(16, 0);
+    sessionSalt.copy(iv, 0, 0, 14);
+    const ssrcBuf = node_buffer.Buffer.allocUnsafe(4);
+    ssrcBuf.writeUInt32BE(ssrc >>> 0, 0);
+    for (let i = 0; i < 4; i++) {
+        iv[4 + i] ^= ssrcBuf[i];
+    }
+    const rocBuf = node_buffer.Buffer.allocUnsafe(4);
+    rocBuf.writeUInt32BE(roc >>> 0, 0);
+    for (let i = 0; i < 4; i++) {
+        iv[8 + i] ^= rocBuf[i];
+    }
+    iv[12] ^= (seqNum >>> 8) & 0xff;
+    iv[13] ^= seqNum & 0xff;
+    return iv;
+}
+function buildSrtcpCtrIv(sessionSalt, ssrc, srtcpIndex) {
+    const iv = node_buffer.Buffer.alloc(16, 0);
+    sessionSalt.copy(iv, 0, 0, 14);
+    const ssrcBuf = node_buffer.Buffer.allocUnsafe(4);
+    ssrcBuf.writeUInt32BE(ssrc >>> 0, 0);
+    for (let i = 0; i < 4; i++) {
+        iv[4 + i] ^= ssrcBuf[i];
+    }
+    const idxBuf = node_buffer.Buffer.allocUnsafe(4);
+    idxBuf.writeUInt32BE((srtcpIndex & 0x7fffffff) >>> 0, 0);
+    for (let i = 0; i < 4; i++) {
+        iv[10 + i] ^= idxBuf[i];
+    }
+    return iv;
+}
+/**
+ * Phiên mã hoá / giải mã SRTP & SRTCP thuần Node.js (`node:crypto`)
+ * tương thích 100% với `zrtc::SrtpTransport` (`AES_CM_128_HMAC_SHA1_80` / `AES_CM_128_HMAC_SHA1_32`).
+ */
+class ZaloSrtpSession {
+    masterKey;
+    masterSalt;
+    masterKeyBase64;
+    suite;
+    tagLength;
+    rtpKey;
+    rtpAuthKey;
+    rtpSalt;
+    rtcpKey;
+    rtcpAuthKey;
+    rtcpSalt;
+    sendRoc = 0;
+    recvRoc = 0;
+    lastSendSeq = -1;
+    lastRecvSeq = -1;
+    srtcpIndex = 0;
+    constructor(masterKeyInput, suite = "AES_CM_128_HMAC_SHA1_80") {
+        const raw = typeof masterKeyInput === "string"
+            ? node_buffer.Buffer.from(masterKeyInput, "base64")
+            : node_buffer.Buffer.from(masterKeyInput);
+        if (raw.length < 30) {
+            throw new ZaloApiError.ZaloApiError(`SRTP master key + salt must be at least 30 bytes (got ${raw.length} bytes)`);
+        }
+        this.masterKey = raw.subarray(0, 16);
+        this.masterSalt = raw.subarray(16, 30);
+        this.masterKeyBase64 = raw.subarray(0, 30).toString("base64");
+        this.suite = suite;
+        this.tagLength = suite === "AES_CM_128_HMAC_SHA1_32" ? 4 : 10;
+        this.rtpKey = deriveSrtpSessionKey(this.masterKey, this.masterSalt, 0x00, 16);
+        this.rtpAuthKey = deriveSrtpSessionKey(this.masterKey, this.masterSalt, 0x01, 20);
+        this.rtpSalt = deriveSrtpSessionKey(this.masterKey, this.masterSalt, 0x02, 14);
+        this.rtcpKey = deriveSrtpSessionKey(this.masterKey, this.masterSalt, 0x03, 16);
+        this.rtcpAuthKey = deriveSrtpSessionKey(this.masterKey, this.masterSalt, 0x04, 20);
+        this.rtcpSalt = deriveSrtpSessionKey(this.masterKey, this.masterSalt, 0x05, 14);
+    }
+    /**
+     * Mã hoá gói tin RTP thành SRTP (AES-128-CTR + HMAC-SHA1 tag).
+     */
+    protectRtp(rtpPacket, explicitRoc) {
+        const parsed = parseRtpPacket(rtpPacket);
+        let roc = explicitRoc ?? this.sendRoc;
+        if (explicitRoc === undefined) {
+            if (this.lastSendSeq !== -1 && parsed.sequenceNumber < this.lastSendSeq && this.lastSendSeq - parsed.sequenceNumber > 0x8000) {
+                this.sendRoc = (this.sendRoc + 1) >>> 0;
+                roc = this.sendRoc;
+            }
+            this.lastSendSeq = parsed.sequenceNumber;
+        }
+        const iv = buildSrtpCtrIv(this.rtpSalt, parsed.ssrc, roc, parsed.sequenceNumber);
+        const cipher = crypto.createCipheriv("aes-128-ctr", this.rtpKey, iv);
+        const encryptedPayload = node_buffer.Buffer.concat([cipher.update(parsed.payload), cipher.final()]);
+        const rocBuf = node_buffer.Buffer.allocUnsafe(4);
+        rocBuf.writeUInt32BE(roc >>> 0, 0);
+        const hmac = crypto.createHmac("sha1", this.rtpAuthKey);
+        hmac.update(parsed.header);
+        hmac.update(encryptedPayload);
+        hmac.update(rocBuf);
+        const authTag = hmac.digest().subarray(0, this.tagLength);
+        return node_buffer.Buffer.concat([parsed.header, encryptedPayload, authTag]);
+    }
+    /**
+     * Xác thực HMAC-SHA1 và giải mã gói tin SRTP về RTP thuần.
+     */
+    unprotectRtp(srtpPacket, explicitRoc) {
+        if (!srtpPacket || srtpPacket.length < 12 + this.tagLength) {
+            throw new ZaloApiError.ZaloApiError(`Invalid SRTP packet length: ${srtpPacket?.length ?? 0}`);
+        }
+        const rtpPortion = srtpPacket.subarray(0, srtpPacket.length - this.tagLength);
+        const receivedTag = srtpPacket.subarray(srtpPacket.length - this.tagLength);
+        const parsed = parseRtpPacket(rtpPortion);
+        let roc = explicitRoc ?? this.recvRoc;
+        if (explicitRoc === undefined && this.lastRecvSeq !== -1) {
+            if (parsed.sequenceNumber < this.lastRecvSeq && this.lastRecvSeq - parsed.sequenceNumber > 0x8000) {
+                roc = (this.recvRoc + 1) >>> 0;
+            }
+        }
+        const rocBuf = node_buffer.Buffer.allocUnsafe(4);
+        rocBuf.writeUInt32BE(roc >>> 0, 0);
+        const hmac = crypto.createHmac("sha1", this.rtpAuthKey);
+        hmac.update(parsed.header);
+        hmac.update(parsed.payload);
+        hmac.update(rocBuf);
+        const expectedTag = hmac.digest().subarray(0, this.tagLength);
+        if (!crypto.timingSafeEqual(receivedTag, expectedTag)) {
+            throw new ZaloApiError.ZaloApiError("SRTP authentication tag verification failed");
+        }
+        if (explicitRoc === undefined) {
+            this.recvRoc = roc;
+            this.lastRecvSeq = parsed.sequenceNumber;
+        }
+        const iv = buildSrtpCtrIv(this.rtpSalt, parsed.ssrc, roc, parsed.sequenceNumber);
+        const decipher = crypto.createDecipheriv("aes-128-ctr", this.rtpKey, iv);
+        const decryptedPayload = node_buffer.Buffer.concat([decipher.update(parsed.payload), decipher.final()]);
+        return node_buffer.Buffer.concat([parsed.header, decryptedPayload]);
+    }
+    /**
+     * Mã hoá gói tin RTCP thành SRTCP (RFC 3711 Mục 3.4).
+     */
+    protectRtcp(rtcpPacket) {
+        if (!rtcpPacket || rtcpPacket.length < 8) {
+            throw new ZaloApiError.ZaloApiError(`Invalid RTCP packet length: ${rtcpPacket?.length ?? 0}`);
+        }
+        const header = rtcpPacket.subarray(0, 8);
+        const payload = rtcpPacket.subarray(8);
+        const ssrc = rtcpPacket.readUInt32BE(4);
+        const index = (this.srtcpIndex++ & 0x7fffffff) >>> 0;
+        const iv = buildSrtcpCtrIv(this.rtcpSalt, ssrc, index);
+        const cipher = crypto.createCipheriv("aes-128-ctr", this.rtcpKey, iv);
+        const encryptedPayload = node_buffer.Buffer.concat([cipher.update(payload), cipher.final()]);
+        const indexTrailer = node_buffer.Buffer.allocUnsafe(4);
+        indexTrailer.writeUInt32BE((0x80000000 | index) >>> 0, 0);
+        const hmac = crypto.createHmac("sha1", this.rtcpAuthKey);
+        hmac.update(header);
+        hmac.update(encryptedPayload);
+        hmac.update(indexTrailer);
+        const authTag = hmac.digest().subarray(0, this.tagLength);
+        return node_buffer.Buffer.concat([header, encryptedPayload, indexTrailer, authTag]);
+    }
+    /**
+     * Xác thực và giải mã gói tin SRTCP về RTCP thuần.
+     */
+    unprotectRtcp(srtcpPacket) {
+        if (!srtcpPacket || srtcpPacket.length < 8 + 4 + this.tagLength) {
+            throw new ZaloApiError.ZaloApiError(`Invalid SRTCP packet length: ${srtcpPacket?.length ?? 0}`);
+        }
+        const tagStart = srtcpPacket.length - this.tagLength;
+        const indexStart = tagStart - 4;
+        const header = srtcpPacket.subarray(0, 8);
+        const encryptedPayload = srtcpPacket.subarray(8, indexStart);
+        const indexTrailer = srtcpPacket.subarray(indexStart, tagStart);
+        const receivedTag = srtcpPacket.subarray(tagStart);
+        const hmac = crypto.createHmac("sha1", this.rtcpAuthKey);
+        hmac.update(header);
+        hmac.update(encryptedPayload);
+        hmac.update(indexTrailer);
+        const expectedTag = hmac.digest().subarray(0, this.tagLength);
+        if (!crypto.timingSafeEqual(receivedTag, expectedTag)) {
+            throw new ZaloApiError.ZaloApiError("SRTCP authentication tag verification failed");
+        }
+        const eAndIndex = indexTrailer.readUInt32BE(0);
+        const isEncrypted = (eAndIndex & 0x80000000) !== 0;
+        const index = eAndIndex & 0x7fffffff;
+        if (!isEncrypted) {
+            return node_buffer.Buffer.concat([header, encryptedPayload]);
+        }
+        const ssrc = header.readUInt32BE(4);
+        const iv = buildSrtcpCtrIv(this.rtcpSalt, ssrc, index);
+        const decipher = crypto.createDecipheriv("aes-128-ctr", this.rtcpKey, iv);
+        const decryptedPayload = node_buffer.Buffer.concat([decipher.update(encryptedPayload), decipher.final()]);
+        return node_buffer.Buffer.concat([header, decryptedPayload]);
+    }
+}
+
+exports.ZaloSrtpSession = ZaloSrtpSession;
+exports.buildRtpPacket = buildRtpPacket;
+exports.deriveSrtpSessionKey = deriveSrtpSessionKey;
+exports.generateSrtpMasterKeyBase64 = generateSrtpMasterKeyBase64;
+exports.parseRtpPacket = parseRtpPacket;

package/dist/cjs/constants/protocol.cjs

@@ -12,7 +12,7 @@ const ZALO_PROTOCOL = {
     API_VERSION: 689,
     DEFAULT_API_VERSION: 689,
     /** Phiên bản SDK hiện tại */
-    SDK_VERSION: "2.3.4",
+    SDK_VERSION: "2.3.5",
     /** Mã zpw_type đặc thù dành riêng cho phân hệ Gọi Thoại & Video (binary C++ ZaloCall) */
     VOICECALL_API_TYPE: 24,
     /** Phiên bản mã hóa ZCID (ParamDecryptor) */

package/dist/cjs/index.cjs

@@ -32,17 +32,9 @@ 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 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 listener = require('./realtime/listener.cjs');
+var zalo = require('./zalo.cjs');
 var loginQR = require('./apis/loginQR.cjs');
 var getFriendRecommendations = require('./apis/friend/getFriendRecommendations.cjs');
 var reviewPendingMemberRequest = require('./apis/group/reviewPendingMemberRequest.cjs');
@@ -53,6 +45,18 @@ 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 ZaloCallController = require('./call-engine/ZaloCallController.cjs');
+var ZaloRtcSession = require('./call-engine/ZaloRtcSession.cjs');
+var ZRTPPacketCodec = require('./call-engine/ZRTPPacketCodec.cjs');
+var ZaloSrtpSession = require('./call-engine/ZaloSrtpSession.cjs');
+var ZaloCallTransport = require('./call-engine/ZaloCallTransport.cjs');
+require('crypto-js');
+require('node:crypto');
+require('node:fs');
+require('node:path');
+require('spark-md5');
+require('tough-cookie');
+require('./context.cjs');
 var apis = require('./apis.cjs');
 
 
@@ -168,11 +172,12 @@ 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 types.CloseReason; }
 });
+exports.Listener = listener.Listener;
+exports.Zalo = zalo.Zalo;
 Object.defineProperty(exports, "LoginQRCallbackEventType", {
 	enumerable: true,
 	get: function () { return loginQR.LoginQRCallbackEventType; }
@@ -221,4 +226,49 @@ Object.defineProperty(exports, "CallType", {
 	enumerable: true,
 	get: function () { return sendVoiceCall.CallType; }
 });
+exports.ZaloCallController = ZaloCallController.ZaloCallController;
+exports.ZaloRtcSession = ZaloRtcSession.ZaloRtcSession;
+exports.parseIncomingCallEvent = ZaloRtcSession.parseIncomingCallEvent;
+exports.DEFAULT_ZALO_AUDIO_CODEC = ZRTPPacketCodec.DEFAULT_ZALO_AUDIO_CODEC;
+exports.DEFAULT_ZALO_VIDEO_CODEC = ZRTPPacketCodec.DEFAULT_ZALO_VIDEO_CODEC;
+Object.defineProperty(exports, "ZRTCMediaSubCommand", {
+	enumerable: true,
+	get: function () { return ZRTPPacketCodec.ZRTCMediaSubCommand; }
+});
+Object.defineProperty(exports, "ZRTCRole", {
+	enumerable: true,
+	get: function () { return ZRTPPacketCodec.ZRTCRole; }
+});
+Object.defineProperty(exports, "ZRTPControlCommand", {
+	enumerable: true,
+	get: function () { return ZRTPPacketCodec.ZRTPControlCommand; }
+});
+Object.defineProperty(exports, "ZRTPForwardSubCommand", {
+	enumerable: true,
+	get: function () { return ZRTPPacketCodec.ZRTPForwardSubCommand; }
+});
+Object.defineProperty(exports, "ZRTPLegacyMediaType", {
+	enumerable: true,
+	get: function () { return ZRTPPacketCodec.ZRTPLegacyMediaType; }
+});
+exports.buildEchoRequest = ZRTPPacketCodec.buildEchoRequest;
+exports.buildEndCallRequest = ZRTPPacketCodec.buildEndCallRequest;
+exports.buildInitCallRequest = ZRTPPacketCodec.buildInitCallRequest;
+exports.buildInitCallResponse = ZRTPPacketCodec.buildInitCallResponse;
+exports.buildPingRequest = ZRTPPacketCodec.buildPingRequest;
+exports.buildPingResponse = ZRTPPacketCodec.buildPingResponse;
+exports.buildRelayPingRequest = ZRTPPacketCodec.buildRelayPingRequest;
+exports.buildRequestForwardPacket = ZRTPPacketCodec.buildRequestForwardPacket;
+exports.buildZrtcExtendData = ZRTPPacketCodec.buildZrtcExtendData;
+exports.parseZRTPPacket = ZRTPPacketCodec.parseZRTPPacket;
+exports.uidToUint32 = ZRTPPacketCodec.uidToUint32;
+exports.wrapLegacyMediaPacket = ZRTPPacketCodec.wrapLegacyMediaPacket;
+exports.wrapZrtcMediaPacket = ZRTPPacketCodec.wrapZrtcMediaPacket;
+exports.ZaloSrtpSession = ZaloSrtpSession.ZaloSrtpSession;
+exports.buildRtpPacket = ZaloSrtpSession.buildRtpPacket;
+exports.deriveSrtpSessionKey = ZaloSrtpSession.deriveSrtpSessionKey;
+exports.generateSrtpMasterKeyBase64 = ZaloSrtpSession.generateSrtpMasterKeyBase64;
+exports.parseRtpPacket = ZaloSrtpSession.parseRtpPacket;
+exports.DEFAULT_ZALOCALL_IPC_KEY_BASE64 = ZaloCallTransport.DEFAULT_ZALOCALL_IPC_KEY_BASE64;
+exports.ZaloCallTransport = ZaloCallTransport.ZaloCallTransport;
 exports.API = apis.API;

package/dist/cjs/models/CallEvent.cjs

@@ -4,11 +4,24 @@ exports.CallEventType = void 0;
 (function (CallEventType) {
     CallEventType["REQUEST"] = "request";
     CallEventType["ANSWER"] = "answer";
+    CallEventType["ANSWER_ACK"] = "answer_ack";
     CallEventType["CANCEL"] = "cancel";
     CallEventType["END"] = "end";
     CallEventType["RINGRING"] = "ringring";
+    CallEventType["ONOFF_CAMERA"] = "onoff_camera";
+    CallEventType["MUTE_AUDIO"] = "mute_audio";
+    CallEventType["AUDIO_TO_VIDEO"] = "audio_to_video";
+    CallEventType["SHARE_SCREEN"] = "share_screen";
     CallEventType["GROUP_REQUEST"] = "group_request";
+    CallEventType["GROUP_RINGRING"] = "group_ring_ring";
     CallEventType["GROUP_ANSWER"] = "group_answer";
+    CallEventType["GROUP_ANSWER_ACK"] = "group_answer_ack";
+    CallEventType["GROUP_CANCEL"] = "group_cancel";
+    CallEventType["GROUP_END"] = "group_end_call";
+    CallEventType["GROUP_ADD_USER"] = "group_add_user";
+    CallEventType["GROUP_NOTIFY"] = "group_notify";
+    CallEventType["GROUP_BROADCAST"] = "group_broadcast";
+    CallEventType["GROUP_BROADCAST_CONFIG"] = "group_broadcast_config";
     CallEventType["UNKNOWN"] = "unknown";
 })(exports.CallEventType || (exports.CallEventType = {}));
 function initializeCallEvent(data, act, act_type) {
@@ -20,31 +33,112 @@ function initializeCallEvent(data, act, act_type) {
         case "answer":
             type = exports.CallEventType.ANSWER;
             break;
+        case "answer_ack":
+        case "answerack":
+            type = exports.CallEventType.ANSWER_ACK;
+            break;
         case "cancel":
             type = exports.CallEventType.CANCEL;
             break;
         case "end":
         case "endcall":
+        case "end_call":
             type = exports.CallEventType.END;
             break;
         case "ringring":
+        case "ring_ring":
             type = exports.CallEventType.RINGRING;
             break;
+        case "onoff_camera":
+            type = exports.CallEventType.ONOFF_CAMERA;
+            break;
+        case "mute_audio":
+            type = exports.CallEventType.MUTE_AUDIO;
+            break;
+        case "audio_to_video":
+            type = exports.CallEventType.AUDIO_TO_VIDEO;
+            break;
+        case "share_screen":
+            type = exports.CallEventType.SHARE_SCREEN;
+            break;
         case "group_request":
             type = exports.CallEventType.GROUP_REQUEST;
             break;
+        case "group_ring_ring":
+        case "group_ringring":
+            type = exports.CallEventType.GROUP_RINGRING;
+            break;
         case "group_answer":
             type = exports.CallEventType.GROUP_ANSWER;
             break;
+        case "group_answer_ack":
+            type = exports.CallEventType.GROUP_ANSWER_ACK;
+            break;
+        case "group_cancel":
+            type = exports.CallEventType.GROUP_CANCEL;
+            break;
+        case "group_end_call":
+        case "group_endcall":
+        case "group_end":
+            type = exports.CallEventType.GROUP_END;
+            break;
+        case "group_add_user":
+            type = exports.CallEventType.GROUP_ADD_USER;
+            break;
+        case "group_notify":
+            type = exports.CallEventType.GROUP_NOTIFY;
+            break;
+        case "group_broadcast":
+            type = exports.CallEventType.GROUP_BROADCAST;
+            break;
+        case "group_broadcast_config":
+            type = exports.CallEventType.GROUP_BROADCAST_CONFIG;
+            break;
         default:
             type = exports.CallEventType.UNKNOWN;
             break;
     }
+    const enrichedData = { ...data };
+    let parsedParams;
+    if (typeof enrichedData.params === "string") {
+        try {
+            const p = JSON.parse(enrichedData.params);
+            if (p && typeof p === "object")
+                parsedParams = p;
+        }
+        catch {
+            // Ignore invalid JSON
+        }
+    }
+    else if (enrichedData.params && typeof enrichedData.params === "object") {
+        parsedParams = enrichedData.params;
+    }
+    if (enrichedData.callId === undefined) {
+        const extractedCallId = Number(enrichedData.call_id ??
+            enrichedData.id ??
+            parsedParams?.callId ??
+            parsedParams?.call_id ??
+            parsedParams?.id ??
+            0);
+        if (extractedCallId > 0) {
+            enrichedData.callId = extractedCallId;
+        }
+    }
+    if (enrichedData.callerId === undefined) {
+        const extractedCallerId = enrichedData.uidN ??
+            parsedParams?.uidN ??
+            enrichedData.uidFrom ??
+            enrichedData.fromId ??
+            parsedParams?.uidFrom;
+        if (extractedCallerId !== undefined) {
+            enrichedData.callerId = String(extractedCallerId);
+        }
+    }
     return {
         type,
         act,
         act_type,
-        data,
+        data: enrichedData,
     };
 }
 

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

@@ -8,10 +8,15 @@ 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;
+    if (version == 1 && (cmd == 601 || cmd == 603 || cmd == 604) && subCmd == 0) {
+        const decoded = await wsCipher.decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data;
+        const controls = parsedData?.controls;
+        if (!Array.isArray(controls))
+            return false;
         for (const control of controls) {
+            if (!control?.content)
+                continue;
             if (control.content.act_type == "file_done") {
                 const data = {
                     fileUrl: control.content.data.url,
@@ -62,6 +67,15 @@ async function handleRealtimeControlPacket(listener, ctx, selfListen, version, c
                 const callEventData = typeof control.content.data == "string"
                     ? JSON.parse(control.content.data)
                     : control.content.data;
+                // Bỏ qua các gói mời gọi cũ (> 60s) nằm trong hàng đợi offline (cmd 603 / 604)
+                if ((cmd == 603 || cmd == 604) &&
+                    (control.content.act == "request" || control.content.act == "group_request") &&
+                    callEventData?.ts) {
+                    const eventTs = Number.parseInt(String(callEventData.ts), 10);
+                    if (Number.isFinite(eventTs) && Date.now() - eventTs > 60_000) {
+                        continue;
+                    }
+                }
                 const callEvent = CallEvent.initializeCallEvent(callEventData, control.content.act, control.content.act_type);
                 listener.emit("call_event", callEvent);
             }

package/dist/cjs/realtime/listener.cjs

@@ -269,6 +269,7 @@ class Listener extends EventEmitter {
                 if (version == 1 && cmd == 1 && subCmd == 1 && utils.hasOwn(parsed, "key")) {
                     this.cipherKey = parsed.key;
                     this.emit("cipher_key", this.cipherKey);
+                    this.requestOfflineVoipControls();
                     if (this.pingInterval)
                         clearInterval(this.pingInterval);
                     const ping = () => {
@@ -374,6 +375,24 @@ class Listener extends EventEmitter {
         };
         this.sendWs(payload);
     }
+    /**
+     * Kích hoạt và kéo hàng đợi sự kiện điều khiển / VoIP (`cmd 603` CTRL_PULL_CTRL và `cmd 604` CTRL_PULL_VOIP).
+     * Giúp nhận ngay các cuộc gọi đến đang đổ chuông ngay cả khi vừa mở kết nối WebSocket.
+     */
+    requestOfflineVoipControls() {
+        this.sendWs({
+            version: 1,
+            cmd: 604,
+            subCmd: 0,
+            data: { first: true, lastId: 1, preIds: [] },
+        });
+        this.sendWs({
+            version: 1,
+            cmd: 603,
+            subCmd: 0,
+            data: { first: true, lastId: "1", preIds: [] },
+        });
+    }
     reset() {
         this.ws = null;
         this.cipherKey = undefined;

package/dist/constants/protocol.d.ts

@@ -10,7 +10,7 @@ export declare const ZALO_PROTOCOL: {
     readonly API_VERSION: 689;
     readonly DEFAULT_API_VERSION: 689;
     /** Phiên bản SDK hiện tại */
-    readonly SDK_VERSION: "2.3.4";
+    readonly SDK_VERSION: "2.3.5";
     /** Mã zpw_type đặc thù dành riêng cho phân hệ Gọi Thoại & Video (binary C++ ZaloCall) */
     readonly VOICECALL_API_TYPE: 24;
     /** Phiên bản mã hóa ZCID (ParamDecryptor) */

package/dist/constants/protocol.js

@@ -10,7 +10,7 @@ export const ZALO_PROTOCOL = {
     API_VERSION: 689,
     DEFAULT_API_VERSION: 689,
     /** Phiên bản SDK hiện tại */
-    SDK_VERSION: "2.3.4",
+    SDK_VERSION: "2.3.5",
     /** Mã zpw_type đặc thù dành riêng cho phân hệ Gọi Thoại & Video (binary C++ ZaloCall) */
     VOICECALL_API_TYPE: 24,
     /** Phiên bản mã hóa ZCID (ParamDecryptor) */