@softtynet/zca-js 2.3.3 → 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.3",
+    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/context.cjs

@@ -5,15 +5,32 @@ var defaults = require('./constants/defaults.cjs');
 
 const _5_MINUTES = defaults.ZALO_DEFAULTS.UPLOAD.CALLBACK_TTL_MS;
 class CallbacksMap extends Map {
+    timers = new Map();
     /**
      * @param ttl Time to live in milliseconds. Default is 5 minutes.
      */
     set(key, value, ttl = _5_MINUTES) {
-        setTimeout(() => {
-            this.delete(key);
+        const existing = this.timers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.timers.delete(key);
+            super.delete(key);
         }, ttl);
+        if (typeof timer === "object" && timer !== null && "unref" in timer && typeof timer.unref === "function") {
+            timer.unref();
+        }
+        this.timers.set(key, timer);
         return super.set(key, value);
     }
+    delete(key) {
+        const existing = this.timers.get(key);
+        if (existing) {
+            clearTimeout(existing);
+            this.timers.delete(key);
+        }
+        return super.delete(key);
+    }
 }
 const createContext = (apiType = protocol.ZALO_PROTOCOL.API_TYPE, apiVersion = protocol.ZALO_PROTOCOL.API_VERSION) => ({
     API_TYPE: apiType,
@@ -24,6 +41,7 @@ const createContext = (apiType = protocol.ZALO_PROTOCOL.API_TYPE, apiVersion = p
         checkUpdate: defaults.ZALO_DEFAULTS.OPTIONS.CHECK_UPDATE,
         logging: defaults.ZALO_DEFAULTS.OPTIONS.LOGGING,
         polyfill: global.fetch,
+        requestTimeout: 30000,
     },
     secretKey: null,
 });

package/dist/cjs/core/zcloud-client.cjs

@@ -4,8 +4,7 @@ var ZaloApiError = require('../Errors/ZaloApiError.cjs');
 require('crypto-js');
 require('node:crypto');
 var zcloudCipher = require('../crypto/zcloud-cipher.cjs');
-require('pako');
-require('json-bigint');
+require('../crypto/ws-cipher.cjs');
 
 /**
  * Thực thi request tới hệ sinh thái ZCloud (`zcld.chat.zalo.me`) kèm cơ chế:

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

@@ -5,6 +5,68 @@ var pako = require('pako');
 var JSONBig = require('json-bigint');
 var ZaloApiError = require('../Errors/ZaloApiError.cjs');
 
+const jsonBigString = JSONBig({ storeAsString: true });
+const DEFAULT_BIGINT_ID_FIELDS = [
+    "owner_id",
+    "group_id",
+    "uidFrom",
+    "uidTo",
+    "uid",
+    "ownerId",
+    "destId",
+    "srcId",
+    "fromUid",
+    "threadId",
+    "globalMsgId",
+    "global_msg_id",
+    "globalDelMsgId",
+    "msgId",
+    "refMessageId",
+    "cliMsgId",
+    "client_msg_id",
+    "actionId",
+    "lastActionIdOther",
+    "lastActionId",
+    "resetLastActionId",
+    "lastId",
+    "ids",
+    "topicId",
+    "reminderId",
+    "eventId",
+];
+/**
+ * Tiền xử lý chuỗi JSON trước khi `JSON.parse` (tương đương `preParse(e, t)` trong `app.asar` của Zalo PC).
+ * Bọc dấu ngoặc kép quanh các trường định danh 64-bit (`owner_id`, `group_id`, hoặc các số nguyên >= 16 chữ số
+ * vượt quá `Number.MAX_SAFE_INTEGER`) để tránh mất 3 chữ số cuối của UID/MsgId do làm tròn IEEE-754.
+ */
+function preParseJsonIds(jsonStr, alwaysStringFields = ["owner_id", "group_id"], bigIntSafeFields = DEFAULT_BIGINT_ID_FIELDS) {
+    if (!jsonStr || typeof jsonStr !== "string")
+        return jsonStr;
+    const alwaysSet = new Set(alwaysStringFields);
+    const allFields = Array.from(new Set([...alwaysStringFields, ...bigIntSafeFields]));
+    if (allFields.length === 0)
+        return jsonStr;
+    const escapedKeys = allFields.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const keyValueRegex = new RegExp(`"(${escapedKeys})"(\\s*:\\s*)(\\d+|\\[\\s*\\d+(?:\\s*,\\s*\\d+)*\\s*\\])`, "g");
+    return jsonStr.replace(keyValueRegex, (fullMatch, key, sep, rawVal) => {
+        const forceString = alwaysSet.has(key);
+        if (rawVal.startsWith("[")) {
+            const inner = rawVal.slice(1, -1);
+            const parts = inner.split(",").map((part) => {
+                const trimmed = part.trim();
+                if (forceString || trimmed.length >= 16 || Number(trimmed) > Number.MAX_SAFE_INTEGER) {
+                    return `"${trimmed}"`;
+                }
+                return trimmed;
+            });
+            return `"${key}"${sep}[${parts.join(",")}]`;
+        }
+        if (forceString || rawVal.length >= 16 || Number(rawVal) > Number.MAX_SAFE_INTEGER) {
+            return `"${key}"${sep}"${rawVal}"`;
+        }
+        return fullMatch;
+    });
+}
 function decodeBase64ToBuffer(data) {
     return Buffer.from(data, "base64");
 }
@@ -26,7 +88,7 @@ async function decodeEventData(parsed, cipherKey) {
     const rawData = parsed.data;
     const encryptType = parsed.encrypt;
     if (encryptType === 0)
-        return JSON.parse(rawData);
+        return jsonBigString.parse(preParseJsonIds(rawData));
     const decodedBuffer = decodeBase64ToBuffer(encryptType === 1 ? rawData : decodeURIComponent(rawData));
     let decryptedBuffer = decodedBuffer;
     if (encryptType !== 1) {
@@ -51,9 +113,11 @@ async function decodeEventData(parsed, cipherKey) {
     const decodedData = decodeUnit8Array(decompressedBuffer);
     if (!decodedData)
         return;
-    return JSONBig.parse(decodedData);
+    return jsonBigString.parse(preParseJsonIds(decodedData));
 }
 
+exports.DEFAULT_BIGINT_ID_FIELDS = DEFAULT_BIGINT_ID_FIELDS;
 exports.decodeBase64ToBuffer = decodeBase64ToBuffer;
 exports.decodeEventData = decodeEventData;
 exports.decodeUnit8Array = decodeUnit8Array;
+exports.preParseJsonIds = preParseJsonIds;

package/dist/cjs/index.cjs

@@ -32,11 +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');
-var utils = require('./utils.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');
@@ -47,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');
 
 
@@ -153,19 +163,21 @@ exports.deriveZdbAesKey = zdbCipher.deriveZdbAesKey;
 exports.generateRSAKeyPair = zdbCipher.generateRSAKeyPair;
 exports.parseZdbHeader = zdbCipher.parseZdbHeader;
 exports.rsaDecryptPkcs1Manual = zdbCipher.rsaDecryptPkcs1Manual;
+exports.DEFAULT_BIGINT_ID_FIELDS = wsCipher.DEFAULT_BIGINT_ID_FIELDS;
 exports.decodeBase64ToBuffer = wsCipher.decodeBase64ToBuffer;
 exports.decodeEventData = wsCipher.decodeEventData;
 exports.decodeUnit8Array = wsCipher.decodeUnit8Array;
+exports.preParseJsonIds = wsCipher.preParseJsonIds;
 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.preParseJsonIds = utils.preParseJsonIds;
+exports.Listener = listener.Listener;
+exports.Zalo = zalo.Zalo;
 Object.defineProperty(exports, "LoginQRCallbackEventType", {
 	enumerable: true,
 	get: function () { return loginQR.LoginQRCallbackEventType; }
@@ -214,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;