@softtynet/zca-js 2.3.4 → 2.3.6

package/dist/call-engine/ZaloSrtpSession.d.ts

@@ -0,0 +1,80 @@
+import { Buffer } from "node:buffer";
+export type SrtpCryptoSuite = "AES_CM_128_HMAC_SHA1_80" | "AES_CM_128_HMAC_SHA1_32";
+export type ParsedRtpPacket = {
+    version: number;
+    padding: boolean;
+    extension: boolean;
+    csrcCount: number;
+    marker: boolean;
+    payloadType: number;
+    sequenceNumber: number;
+    timestamp: number;
+    ssrc: number;
+    headerLength: number;
+    header: Buffer;
+    payload: Buffer;
+};
+export type BuildRtpPacketOptions = {
+    payloadType?: number;
+    sequenceNumber: number;
+    timestamp: number;
+    ssrc: number;
+    marker?: boolean;
+    payload: Buffer;
+};
+/**
+ * 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.
+ */
+export declare function generateSrtpMasterKeyBase64(): string;
+/**
+ * Đóng gói gói tin chuẩn WebRTC RTP (12-byte header + payload).
+ */
+export declare function buildRtpPacket(options: BuildRtpPacketOptions): Buffer;
+/**
+ * Phân tích gói tin chuẩn WebRTC RTP (RFC 3550).
+ */
+export declare function parseRtpPacket(packet: Buffer): ParsedRtpPacket;
+/**
+ * Thuật toán dẫn xuất khoá phiên SRTP/SRTCP theo RFC 3711 Mục 4.3.1 (AES-CM PRF).
+ */
+export declare function deriveSrtpSessionKey(masterKey: Buffer, masterSalt: Buffer, label: number, outByteLength: number): Buffer;
+/**
+ * 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`).
+ */
+export declare class ZaloSrtpSession {
+    readonly masterKey: Buffer;
+    readonly masterSalt: Buffer;
+    readonly masterKeyBase64: string;
+    readonly suite: SrtpCryptoSuite;
+    readonly tagLength: number;
+    readonly rtpKey: Buffer;
+    readonly rtpAuthKey: Buffer;
+    readonly rtpSalt: Buffer;
+    readonly rtcpKey: Buffer;
+    readonly rtcpAuthKey: Buffer;
+    readonly rtcpSalt: Buffer;
+    private sendRoc;
+    private recvRoc;
+    private lastSendSeq;
+    private lastRecvSeq;
+    private srtcpIndex;
+    constructor(masterKeyInput: string | Buffer, suite?: SrtpCryptoSuite);
+    /**
+     * Mã hoá gói tin RTP thành SRTP (AES-128-CTR + HMAC-SHA1 tag).
+     */
+    protectRtp(rtpPacket: Buffer, explicitRoc?: number): Buffer;
+    /**
+     * Xác thực HMAC-SHA1 và giải mã gói tin SRTP về RTP thuần.
+     */
+    unprotectRtp(srtpPacket: Buffer, explicitRoc?: number): Buffer;
+    /**
+     * Mã hoá gói tin RTCP thành SRTCP (RFC 3711 Mục 3.4).
+     */
+    protectRtcp(rtcpPacket: Buffer): Buffer;
+    /**
+     * Xác thực và giải mã gói tin SRTCP về RTCP thuần.
+     */
+    unprotectRtcp(srtcpPacket: Buffer): Buffer;
+}

package/dist/call-engine/ZaloSrtpSession.js

@@ -0,0 +1,278 @@
+import crypto from "node:crypto";
+import { Buffer } from "node:buffer";
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+/**
+ * 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.
+ */
+export function generateSrtpMasterKeyBase64() {
+    return crypto.randomBytes(30).toString("base64");
+}
+/**
+ * Đóng gói gói tin chuẩn WebRTC RTP (12-byte header + payload).
+ */
+export function buildRtpPacket(options) {
+    const header = 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 Buffer.concat([header, options.payload]);
+}
+/**
+ * Phân tích gói tin chuẩn WebRTC RTP (RFC 3550).
+ */
+export function parseRtpPacket(packet) {
+    if (!packet || packet.length < 12) {
+        throw new 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("RTP packet shorter than CSRC header length");
+    }
+    if (extension) {
+        if (packet.length < headerLength + 4) {
+            throw new ZaloApiError("RTP packet shorter than extension header");
+        }
+        const extLenWords = packet.readUInt16BE(headerLength + 2);
+        headerLength += 4 + extLenWords * 4;
+        if (packet.length < headerLength) {
+            throw new 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).
+ */
+export function deriveSrtpSessionKey(masterKey, masterSalt, label, outByteLength) {
+    const iv = 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 = Buffer.alloc(outByteLength, 0);
+    return Buffer.concat([cipher.update(zeroBlock), cipher.final()]).subarray(0, outByteLength);
+}
+function buildSrtpCtrIv(sessionSalt, ssrc, roc, seqNum) {
+    const iv = Buffer.alloc(16, 0);
+    sessionSalt.copy(iv, 0, 0, 14);
+    const ssrcBuf = Buffer.allocUnsafe(4);
+    ssrcBuf.writeUInt32BE(ssrc >>> 0, 0);
+    for (let i = 0; i < 4; i++) {
+        iv[4 + i] ^= ssrcBuf[i];
+    }
+    const rocBuf = 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 = Buffer.alloc(16, 0);
+    sessionSalt.copy(iv, 0, 0, 14);
+    const ssrcBuf = Buffer.allocUnsafe(4);
+    ssrcBuf.writeUInt32BE(ssrc >>> 0, 0);
+    for (let i = 0; i < 4; i++) {
+        iv[4 + i] ^= ssrcBuf[i];
+    }
+    const idxBuf = 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`).
+ */
+export 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"
+            ? Buffer.from(masterKeyInput, "base64")
+            : Buffer.from(masterKeyInput);
+        if (raw.length < 30) {
+            throw new 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 = Buffer.concat([cipher.update(parsed.payload), cipher.final()]);
+        const rocBuf = 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 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(`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 = 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("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 = Buffer.concat([decipher.update(parsed.payload), decipher.final()]);
+        return 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(`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 = Buffer.concat([cipher.update(payload), cipher.final()]);
+        const indexTrailer = 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 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(`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("SRTCP authentication tag verification failed");
+        }
+        const eAndIndex = indexTrailer.readUInt32BE(0);
+        const isEncrypted = (eAndIndex & 0x80000000) !== 0;
+        const index = eAndIndex & 0x7fffffff;
+        if (!isEncrypted) {
+            return 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 = Buffer.concat([decipher.update(encryptedPayload), decipher.final()]);
+        return Buffer.concat([header, decryptedPayload]);
+    }
+}

package/dist/call-engine/index.d.ts

@@ -0,0 +1,18 @@
+import type { API } from "../apis.js";
+import type { ContextSession } from "../context.js";
+import { ZaloCallController, type ZaloCallControllerOptions } from "./ZaloCallController.js";
+import { ZaloRtcSession, type ZaloRtcSessionOptions } from "./ZaloRtcSession.js";
+export * from "./ZRTPPacketCodec.js";
+export * from "./ZaloSrtpSession.js";
+export * from "./ZaloRtcSession.js";
+export * from "./ZaloCallTransport.js";
+export * from "./ZaloCallController.js";
+/**
+ * Factory khởi tạo phiên gọi thuần TypeScript / Node.js (`ZaloRtcSession` — UDP `ZRTPPacket` + `SRTP`)
+ * không phụ thuộc Zalo PC, dùng cho Worker / Server / Mobile Bridge / Desktop.
+ */
+export declare function createRtcSessionFactory(_ctx: ContextSession, api: API): (options?: ZaloRtcSessionOptions) => ZaloRtcSession;
+/**
+ * Factory khởi tạo bộ điều phối cuộc gọi thuần TypeScript `ZaloCallController` (`ZaloRtcSession` + `ZaloCallTransport`).
+ */
+export declare function createCallControllerFactory(_ctx: ContextSession, api: API): (options?: ZaloCallControllerOptions) => ZaloCallController;

package/dist/call-engine/index.js

@@ -0,0 +1,24 @@
+import { ZaloCallController } from "./ZaloCallController.js";
+import { ZaloRtcSession } from "./ZaloRtcSession.js";
+export * from "./ZRTPPacketCodec.js";
+export * from "./ZaloSrtpSession.js";
+export * from "./ZaloRtcSession.js";
+export * from "./ZaloCallTransport.js";
+export * from "./ZaloCallController.js";
+/**
+ * Factory khởi tạo phiên gọi thuần TypeScript / Node.js (`ZaloRtcSession` — UDP `ZRTPPacket` + `SRTP`)
+ * không phụ thuộc Zalo PC, dùng cho Worker / Server / Mobile Bridge / Desktop.
+ */
+export function createRtcSessionFactory(_ctx, api) {
+    return function createRtcSession(options = {}) {
+        return new ZaloRtcSession(api, options);
+    };
+}
+/**
+ * Factory khởi tạo bộ điều phối cuộc gọi thuần TypeScript `ZaloCallController` (`ZaloRtcSession` + `ZaloCallTransport`).
+ */
+export function createCallControllerFactory(_ctx, api) {
+    return function createController(options = {}) {
+        return new ZaloCallController(api, options);
+    };
+}

package/dist/cjs/apis/call/addUserGroupCall.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const addUserGroupCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Mời thêm thành viên vào cuộc gọi nhóm đang diễn ra (`/api/voicecall/group/adduser`, command `12435`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `session`, `partners`, `calleeId`, `callType` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function addUserGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!options?.session)
+            throw new ZaloApiError.ZaloApiError("Missing session");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            calleeId: options.calleeId ?? "",
+            callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            hostCall: String(options.hostCall),
+            data: dataStr,
+            session: options.session,
+            partners: (options.partners ?? []).map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt addUserGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/adduser`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.addUserGroupCallFactory = addUserGroupCallFactory;

package/dist/cjs/apis/call/answerAckVoiceCall.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const answerAckVoiceCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Xác nhận bắt tay hoàn tất từ phía người gọi sau khi người nhận bắt máy (`/api/voicecall/answerack`, command `11304`, signal `408`).
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param callId ID của cuộc gọi
+     * @param options Tuỳ chọn mã trạng thái (`status`, mặc định `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function answerAckVoiceCall(calleeId, callId, options = {}) {
+        if (!calleeId)
+            throw new ZaloApiError.ZaloApiError("Missing calleeId");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            calleeId: String(calleeId),
+            callId,
+            status: options.status ?? 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt answerAckVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/answerack`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.answerAckVoiceCallFactory = answerAckVoiceCallFactory;

package/dist/cjs/apis/call/answerGroupCall.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const answerGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Chấp nhận / Nghe cuộc gọi nhóm đến (`/api/voicecall/group/answer`, command `12436`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `calleeId`, `callType`, `partners` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function answerGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            calleeId: String(options.calleeId ?? ctx.uid),
+            callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            hostCall: String(options.hostCall),
+            data: dataStr,
+            partners: (options.partners ?? []).map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt answerGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/answer`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.answerGroupCallFactory = answerGroupCallFactory;

package/dist/cjs/apis/call/answerVoiceCall.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const answerVoiceCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Chấp nhận / Nghe cuộc gọi thoại hoặc video đến (`/api/voicecall/answer`, command `11303`, signal `402`).
+     *
+     * @param callerId User ID của người gọi đến
+     * @param callId ID của cuộc gọi
+     * @param options Thông tin `sessionId`, `rtpAddress`, `rtcpAddress`, `codec`, `extendData` và `status`
+     * @throws {ZaloApiError}
+     */
+    return async function answerVoiceCall(callerId, callId, options = {}) {
+        if (!callerId)
+            throw new ZaloApiError.ZaloApiError("Missing callerId");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const extendDataStr = options.extendData === undefined
+            ? undefined
+            : typeof options.extendData === "string"
+                ? options.extendData
+                : JSON.stringify(options.extendData);
+        const params = {
+            callerId: String(callerId),
+            callId,
+            status: options.status ?? 0,
+            codec: options.codec ?? "",
+            rtcpAddress: options.rtcpAddress ?? "",
+            rtpAddress: options.rtpAddress ?? "",
+            session_id: options.sessionId ?? "",
+        };
+        if (extendDataStr) {
+            params.extendData = extendDataStr;
+            params.subCommand = options.subCommand ?? 3;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt answerVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/answer`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.answerVoiceCallFactory = answerVoiceCallFactory;

package/dist/cjs/apis/call/broadcastGroupCallState.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const broadcastGroupCallStateFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Phát (broadcast) trạng thái âm thanh / hình ảnh của thành viên trong cuộc gọi nhóm (`/api/voicecall/group/broadcast`, command `12098`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `userId`, `callState`, `audioState`, `videoState` và `params`
+     * @throws {ZaloApiError}
+     */
+    return async function broadcastGroupCallState(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const paramsStr = options.params === undefined
+            ? "{}"
+            : typeof options.params === "string"
+                ? options.params
+                : JSON.stringify(options.params);
+        const payload = {
+            callId,
+            hostCall: String(options.hostCall),
+            userId: String(options.userId ?? ctx.uid),
+            callstate: options.callState ?? 1,
+            audiostate: options.audioState ?? 1,
+            videostate: options.videoState ?? 0,
+            params: paramsStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(payload));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt broadcastGroupCallState params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/broadcast`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.broadcastGroupCallStateFactory = broadcastGroupCallStateFactory;