@softtynet/zca-js 2.2.9 → 2.3.1

package/dist/realtime/listener.js

@@ -0,0 +1,363 @@
+import EventEmitter from "events";
+import WebSocket from "ws";
+import { ThreadType } from "../models/index.js";
+import { getBrowserLanguage, hasOwn, logger, makeURL, ZALO_DEFAULTS, ZALO_DOMAINS } from "../utils.js";
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { CloseReason, } from "./types.js";
+import { handleRealtimeMessagePacket } from "./handlers/message.handler.js";
+import { handleRealtimeControlPacket } from "./handlers/control.handler.js";
+import { handleRealtimeReactionPacket } from "./handlers/reaction.handler.js";
+import { handleRealtimeStatusPacket } from "./handlers/status.handler.js";
+export class Listener extends EventEmitter {
+    ctx;
+    urls;
+    wsURL;
+    cookie;
+    userAgent;
+    ws;
+    retryCount;
+    rotateCount;
+    onConnectedCallback;
+    onClosedCallback;
+    onErrorCallback;
+    onMessageCallback;
+    cipherKey;
+    selfListen;
+    pingInterval;
+    retryTimeout;
+    watchdogTimeout;
+    consecutive1006Count = 0;
+    id = 0;
+    constructor(ctx, urls) {
+        super();
+        this.ctx = ctx;
+        this.urls = urls;
+        if (!ctx.cookie)
+            throw new ZaloApiError("Cookie is not available");
+        if (!ctx.userAgent)
+            throw new ZaloApiError("User agent is not available");
+        this.wsURL = makeURL(this.ctx, this.urls[0], {
+            t: Date.now(),
+        });
+        this.retryCount = {};
+        this.rotateCount = 0;
+        for (const retry in ctx.settings.features.socket.retries) {
+            const { times, max } = ctx.settings.features.socket.retries[retry];
+            this.retryCount[retry] = {
+                count: 0,
+                max: max || 0,
+                times: typeof times === "number" ? [times] : times,
+            };
+        }
+        this.cookie = ctx.cookie.getCookieStringSync(ZALO_DOMAINS.CHAT_WEB);
+        this.userAgent = ctx.userAgent;
+        this.selfListen = ctx.options.selfListen;
+        this.ws = null;
+        this.onConnectedCallback = () => { };
+        this.onClosedCallback = () => { };
+        this.onErrorCallback = () => { };
+        this.onMessageCallback = () => { };
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onConnected(cb) {
+        this.onConnectedCallback = cb;
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onClosed(cb) {
+        this.onClosedCallback = cb;
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onError(cb) {
+        this.onErrorCallback = cb;
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onMessage(cb) {
+        this.onMessageCallback = cb;
+    }
+    isRetryable(code) {
+        return (code === CloseReason.AbnormalClosure ||
+            this.ctx.settings.features.socket.close_and_retry_codes.includes(code));
+    }
+    canRetry(code) {
+        if (!this.isRetryable(code))
+            return false;
+        const retry = this.retryCount[code.toString()] ?? this.retryCount["internal"];
+        if (!retry || retry.count >= retry.max)
+            return false;
+        retry.count++;
+        const { count, max, times } = retry;
+        let retryTime;
+        if (count - 1 < times.length) {
+            retryTime = times[count - 1];
+        }
+        else {
+            const lastTime = times[times.length - 1] || 1000;
+            const multiplier = Math.min(Math.pow(1.5, count - times.length), 10);
+            const jitter = Math.floor(Math.random() * 1000);
+            retryTime = Math.min(Math.floor(lastTime * multiplier) + jitter, ZALO_DEFAULTS.SOCKET.MAX_RETRY_BACKOFF_MS);
+        }
+        logger(this.ctx).verbose(`Retry for code ${code} in ${retryTime}ms (${count}/${max})`);
+        return retryTime;
+    }
+    resetRetryCount() {
+        for (const retry of Object.values(this.retryCount)) {
+            retry.count = 0;
+        }
+    }
+    resetWatchdog() {
+        if (this.watchdogTimeout)
+            clearTimeout(this.watchdogTimeout);
+        this.watchdogTimeout = setTimeout(() => {
+            logger(this.ctx).verbose("Watchdog timeout: no packet/pong received from Zalo WebSocket in 50s. Forcing reconnect...");
+            if (this.ws) {
+                try {
+                    if (typeof this.ws.terminate === "function") {
+                        this.ws.terminate();
+                    }
+                    else if (typeof this.ws.close === "function") {
+                        this.ws.close(CloseReason.AbnormalClosure);
+                    }
+                }
+                catch {
+                    // Ignore if already terminated
+                }
+            }
+        }, ZALO_DEFAULTS.SOCKET.WATCHDOG_TIMEOUT_MS);
+    }
+    shouldRotate(code) {
+        if (code === CloseReason.AbnormalClosure) {
+            this.consecutive1006Count++;
+            if (this.consecutive1006Count >= ZALO_DEFAULTS.SOCKET.CONSECUTIVE_1006_ROTATE_THRESHOLD) {
+                this.consecutive1006Count = 0;
+                return true;
+            }
+            return false;
+        }
+        this.consecutive1006Count = 0;
+        return this.ctx.settings.features.socket.rotate_error_codes.includes(code);
+    }
+    rotateEndpoint() {
+        this.rotateCount = (this.rotateCount + 1) % this.urls.length;
+        this.wsURL = makeURL(this.ctx, this.urls[this.rotateCount], {
+            t: Date.now(),
+        });
+        logger(this.ctx).verbose(`Rotating endpoint to ${this.wsURL}`);
+    }
+    start({ retryOnClose = false } = {}) {
+        if (this.retryTimeout) {
+            clearTimeout(this.retryTimeout);
+            this.retryTimeout = undefined;
+        }
+        if (this.ws) {
+            const state = this.ws.readyState;
+            if (state === WebSocket.CONNECTING || state === WebSocket.OPEN) {
+                logger(this.ctx).warn("Listener is already active or connecting. Skipping duplicate start().");
+                return;
+            }
+            try {
+                this.ws.removeAllListeners();
+                this.ws.close();
+            }
+            catch {
+                // ignore
+            }
+            this.ws = null;
+        }
+        this.wsURL = makeURL(this.ctx, this.urls[this.rotateCount], {
+            t: Date.now(),
+        });
+        const cookie = this.ctx.cookie.getCookieStringSync(ZALO_DOMAINS.CHAT_WEB);
+        const ws = new WebSocket(this.wsURL, {
+            headers: {
+                "accept-language": getBrowserLanguage(this.ctx.language),
+                "cache-control": "no-cache",
+                connection: "Upgrade",
+                host: new URL(this.wsURL).host,
+                origin: ZALO_DOMAINS.CHAT_WEB,
+                pragma: "no-cache",
+                "sec-websocket-extensions": "permessage-deflate; client_max_window_bits",
+                "sec-websocket-version": "13",
+                upgrade: "websocket",
+                "user-agent": this.userAgent,
+                cookie,
+            },
+            agent: this.ctx.options.agent,
+        });
+        this.ws = ws;
+        ws.onopen = () => {
+            this.consecutive1006Count = 0;
+            this.resetRetryCount();
+            this.resetWatchdog();
+            this.onConnectedCallback();
+            this.emit("connected");
+        };
+        ws.onclose = (event) => {
+            this.reset();
+            this.emit("disconnected", event.code, event.reason);
+            const retry = retryOnClose &&
+                this.isRetryable(event.code) &&
+                this.canRetry(event.code);
+            if (retry && retryOnClose) {
+                const shouldRotate = this.shouldRotate(event.code);
+                if (shouldRotate) {
+                    this.rotateEndpoint();
+                }
+                this.emit("reconnecting", event.code);
+                this.retryTimeout = setTimeout(() => {
+                    try {
+                        this.start({ retryOnClose: true });
+                    }
+                    catch (error) {
+                        logger(this.ctx).error("Failed to auto-restart listener on retry timeout:", error);
+                    }
+                }, retry);
+            }
+            else {
+                this.onClosedCallback(event.code, event.reason);
+                this.emit("closed", event.code, event.reason);
+            }
+        };
+        ws.onerror = (event) => {
+            this.onErrorCallback(event);
+            this.emit("error", event);
+        };
+        ws.onmessage = async (event) => {
+            this.resetWatchdog();
+            this.emit("pong");
+            const { data } = event;
+            if (!(data instanceof Buffer))
+                return;
+            const encodedHeader = data.subarray(0, 4);
+            const [version, cmd, subCmd] = getHeader(encodedHeader);
+            try {
+                const dataToDecode = data.subarray(4);
+                const decodedData = new TextDecoder("utf-8").decode(dataToDecode);
+                if (decodedData.length == 0)
+                    return;
+                const parsed = JSON.parse(decodedData);
+                if (version == 1 && cmd == 1 && subCmd == 1 && hasOwn(parsed, "key")) {
+                    this.cipherKey = parsed.key;
+                    this.emit("cipher_key", this.cipherKey);
+                    if (this.pingInterval)
+                        clearInterval(this.pingInterval);
+                    const ping = () => {
+                        const payload = {
+                            version: 1,
+                            cmd: 2,
+                            subCmd: 1,
+                            data: { eventId: Date.now() },
+                        };
+                        this.sendWs(payload, false);
+                        this.emit("ping");
+                    };
+                    const pingIntervalTime = Math.min(Math.max(this.ctx.settings?.features?.socket?.ping_interval ||
+                        ZALO_DEFAULTS.SOCKET.DEFAULT_PING_INTERVAL_MS, ZALO_DEFAULTS.SOCKET.MIN_PING_INTERVAL_MS), ZALO_DEFAULTS.SOCKET.MAX_PING_INTERVAL_MS);
+                    this.pingInterval = setInterval(() => {
+                        ping();
+                    }, pingIntervalTime);
+                }
+                await handleRealtimeMessagePacket(this, this.ctx, this.selfListen, this.onMessageCallback, version, cmd, subCmd, parsed, this.cipherKey);
+                await handleRealtimeControlPacket(this, this.ctx, this.selfListen, version, cmd, subCmd, parsed, this.cipherKey);
+                await handleRealtimeReactionPacket(this, this.ctx, this.selfListen, cmd, parsed, this.cipherKey);
+                await handleRealtimeStatusPacket(this, this.ctx, this.selfListen, cmd, subCmd, parsed, this.cipherKey);
+                if (version == 1 && cmd == 3000 && subCmd == 0) {
+                    logger(this.ctx).error();
+                    logger(this.ctx).error("Another connection is opened, closing this one");
+                    logger(this.ctx).error();
+                    if (ws.readyState !== WebSocket.CLOSED)
+                        ws.close(CloseReason.DuplicateConnection);
+                }
+            }
+            catch (error) {
+                if (error instanceof ZaloApiError &&
+                    error.message.includes("Invalid data length or missing cipher key")) {
+                    logger(this.ctx).verbose("Ignored undecryptable Zalo packet. This is normal for some reaction/system events.");
+                    return;
+                }
+                this.onErrorCallback(error);
+                this.emit("error", error);
+            }
+        };
+    }
+    stop() {
+        if (this.retryTimeout)
+            clearTimeout(this.retryTimeout);
+        if (this.watchdogTimeout)
+            clearTimeout(this.watchdogTimeout);
+        if (this.ws) {
+            if (this.ws.readyState !== WebSocket.CLOSED) {
+                this.ws.close(CloseReason.ManualClosure);
+            }
+        }
+        this.reset();
+    }
+    sendWs(payload, requireId = true) {
+        if (this.ws) {
+            if (requireId)
+                payload.data["req_id"] = `req_${this.id++}`;
+            const encodedData = new TextEncoder().encode(JSON.stringify(payload.data));
+            const dataLength = encodedData.length;
+            const data = new DataView(Buffer.alloc(4 + dataLength).buffer);
+            data.setUint8(0, payload.version);
+            data.setInt32(1, payload.cmd, true);
+            data.setInt8(3, payload.subCmd);
+            encodedData.forEach((e, i) => {
+                data.setUint8(4 + i, e);
+            });
+            this.ws.send(data);
+        }
+    }
+    /**
+     * Request old messages from Zalo WebSocket queue (`cmd 510` for User, `cmd 511` for Group).
+     * When `lastMsgId` is `null` or omitted, defaults to `"10000000000000000"` to fetch the latest offline messages.
+     *
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID (`actionId`) for pagination
+     */
+    requestOldMessages(threadType, lastMsgId = null) {
+        const payload = {
+            version: 1,
+            cmd: threadType === ThreadType.User ? 510 : 511,
+            subCmd: 1,
+            data: { first: true, lastId: lastMsgId ?? ZALO_DEFAULTS.SOCKET.OLD_MSG_INITIAL_CURSOR, preIds: [] },
+        };
+        this.sendWs(payload);
+    }
+    /**
+     * Request old reactions
+     *
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID
+     */
+    requestOldReactions(threadType, lastMsgId = null) {
+        const payload = {
+            version: 1,
+            cmd: threadType === ThreadType.User ? 610 : 611,
+            subCmd: 1,
+            data: { first: true, lastId: lastMsgId, preIds: [] },
+        };
+        this.sendWs(payload);
+    }
+    reset() {
+        this.ws = null;
+        this.cipherKey = undefined;
+        if (this.pingInterval)
+            clearInterval(this.pingInterval);
+        if (this.watchdogTimeout)
+            clearTimeout(this.watchdogTimeout);
+    }
+}
+function getHeader(buffer) {
+    if (buffer.byteLength < 4) {
+        throw new ZaloApiError("Invalid header");
+    }
+    return [buffer[0], buffer.readUInt16LE(1), buffer[3]];
+}

package/dist/realtime/types.d.ts

@@ -0,0 +1,64 @@
+import type { FriendEvent } from "../models/FriendEvent.js";
+import type { GroupEvent } from "../models/GroupEvent.js";
+import type { Message, Reaction, Undo, Typing, ThreadType } from "../models/index.js";
+import type { SeenMessage } from "../models/SeenMessage.js";
+import type { DeliveredMessage } from "../models/DeliveredMessage.js";
+import type { ClearUnread } from "../models/ClearUnread.js";
+import type { SyncEvent } from "../models/SyncEvent.js";
+import type { CallEvent } from "../models/CallEvent.js";
+export type UploadEventData = {
+    fileUrl: string;
+    fileId: string;
+};
+export type Voice2TextEventData = {
+    req_id: string;
+    err?: number;
+    text?: string;
+    content?: string;
+    [key: string]: unknown;
+};
+export type Voice2TextEvent = {
+    act: string;
+    act_type: "voice2text";
+    data: Voice2TextEventData;
+};
+export type WsPayload<T = Record<string, unknown>> = {
+    version: number;
+    cmd: number;
+    subCmd: number;
+    data: T;
+};
+export type OnMessageCallback = (message: Message) => unknown;
+export type OnClosedCallback = (code: CloseReason, reason: string) => unknown;
+export type OnErrorCallback = (error: unknown) => unknown;
+export declare enum CloseReason {
+    ManualClosure = 1000,
+    AbnormalClosure = 1006,
+    DuplicateConnection = 3000,
+    KickConnection = 3003
+}
+export interface ListenerEvents {
+    connected: [];
+    disconnected: [code: CloseReason, reason: string];
+    reconnecting: [code: CloseReason];
+    closed: [code: CloseReason, reason: string];
+    error: [error: unknown];
+    typing: [typing: Typing];
+    message: [message: Message];
+    old_messages: [messages: Message[], type: ThreadType, hasMore?: boolean];
+    seen_messages: [messages: SeenMessage[]];
+    delivered_messages: [messages: DeliveredMessage[]];
+    unread_cleared: [items: ClearUnread[]];
+    reaction: [reaction: Reaction];
+    old_reactions: [reactions: Reaction[], isGroup: boolean];
+    upload_attachment: [data: UploadEventData];
+    undo: [data: Undo];
+    friend_event: [data: FriendEvent];
+    group_event: [data: GroupEvent];
+    sync_event: [data: SyncEvent];
+    call_event: [data: CallEvent];
+    voice2text_event: [data: Voice2TextEvent];
+    cipher_key: [key: string];
+    ping: [];
+    pong: [];
+}

package/dist/realtime/types.js

@@ -0,0 +1,7 @@
+export var CloseReason;
+(function (CloseReason) {
+    CloseReason[CloseReason["ManualClosure"] = 1000] = "ManualClosure";
+    CloseReason[CloseReason["AbnormalClosure"] = 1006] = "AbnormalClosure";
+    CloseReason[CloseReason["DuplicateConnection"] = 3000] = "DuplicateConnection";
+    CloseReason[CloseReason["KickConnection"] = 3003] = "KickConnection";
+})(CloseReason || (CloseReason = {}));

package/dist/update.js

@@ -1,25 +1,27 @@
 import { compare } from "semver";
 import { isBun, logger } from "./utils.js";
-const VERSION = "2.2.7";
-const NPM_REGISTRY = "https://registry.npmjs.org/@softtynet/zca-js";
+import { ZALO_DOMAINS, ZALO_PROTOCOL } from "./constants/index.js";
+const VERSION = ZALO_PROTOCOL.SDK_VERSION;
+const NPM_REGISTRY = ZALO_DOMAINS.NPM_REGISTRY;
 export async function checkUpdate(ctx) {
-    var _a, _b, _c;
     if (!ctx.options.checkUpdate)
         return;
-    const _options = Object.assign({}, (isBun
-        ? {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            proxy: (_b = (_a = ctx.options.agent) === null || _a === void 0 ? void 0 : _a.proxy) === null || _b === void 0 ? void 0 : _b.href,
-        }
-        : { agent: ctx.options.agent }));
+    const _options = {
+        ...(isBun
+            ? {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                proxy: ctx.options.agent?.proxy?.href,
+            }
+            : { agent: ctx.options.agent }),
+    };
     const response = await ctx.options.polyfill(NPM_REGISTRY, _options).catch(() => null);
     if (!response || !response.ok)
         return;
     const data = await response.json().catch(() => null);
     if (!data)
         return;
-    const latestVersion = (_c = data["dist-tags"]) === null || _c === void 0 ? void 0 : _c.latest;
+    const latestVersion = data["dist-tags"]?.latest;
     if (!latestVersion)
         return;
     if (compare(VERSION, latestVersion) === -1) {

package/dist/utils.d.ts

@@ -4,6 +4,10 @@ import { FriendEventType } from "./models/FriendEvent.js";
 import { GroupEventType } from "./models/GroupEvent.js";
 import type { API } from "./zalo.js";
 import type { AttachmentSource } from "./models/Attachment.js";
+import { encodeAES } from "./crypto/index.js";
+export * from "./constants/index.js";
+export * from "./crypto/index.js";
+export * from "./core/index.js";
 export declare const isBun: boolean;
 export declare function hasOwn(obj: Record<string, unknown>, key: string): key is keyof typeof obj;
 /**
@@ -12,7 +16,6 @@ export declare function hasOwn(obj: Record<string, unknown>, key: string): key i
  * @param type
  * @param params
  * @returns MD5 hash
- *
  */
 export declare function getSignKey(type: string, params: Record<string, unknown>): string;
 /**
@@ -21,63 +24,17 @@ export declare function getSignKey(type: string, params: Record<string, unknown>
  * @param params
  * @param apiVersion automatically add zalo api version to url params
  * @returns
- *
  */
 export declare function makeURL(ctx: ContextBase, baseURL: string, params?: Record<string, string | number>, apiVersion?: boolean): string;
-export declare class ParamsEncryptor {
-    private zcid;
-    private enc_ver;
-    private zcid_ext;
-    private encryptKey;
-    constructor({ type, imei, firstLaunchTime }: {
-        type: number;
-        imei: string;
-        firstLaunchTime: number;
-    });
-    getEncryptKey(): string;
-    createZcid(type: number, imei: string, firstLaunchTime: number): void;
-    createEncryptKey(e?: number): boolean;
-    getParams(): {
-        zcid: string;
-        zcid_ext: string;
-        enc_ver: string;
-    } | null;
-    static processStr(e: string): {
-        even: null;
-        odd: null;
-    } | {
-        even: string[];
-        odd: string[];
-    };
-    static randomString(e?: number, t?: number): string;
-    static encodeAES(e: string, message: string, type: "hex" | "base64", uppercase: boolean, s?: number): string | null;
-}
-export declare function decryptResp(key: string, data: string): Record<string, unknown> | null | string;
-export declare function decodeBase64ToBuffer(data: string): Buffer;
-export declare function decodeUnit8Array(data: Uint8Array): string | null;
-export declare function encodeAES(secretKey: string, data: cryptojs.lib.WordArray | string, t?: number): string | null;
-export declare function decodeAES(secretKey: string, data: string, t?: number): string | null;
 /**
  * Suy luận nền tảng hệ điều hành (OS) từ chuỗi User-Agent.
  *
- * Hàm này được sinh ra để giải quyết vấn đề cốt lõi: thư viện zca-js trước đây
- * hardcode `sec-ch-ua-platform: "Windows"` ở 8 chỗ trong loginQR, trong khi
- * User-Agent có thể là Mac/Linux — tạo ra Browser Mismatch khiến Zalo ban session.
- *
- * Thứ tự ưu tiên nhận diện: Windows → macOS → Linux → mặc định Windows (an toàn nhất)
- *
  * @returns Chuỗi platform theo định dạng Sec-CH-UA-Platform, ví dụ: "Windows", "macOS", "Linux"
  */
 export declare function getPlatformFromUA(userAgent: string | undefined): string;
 /**
  * Trích xuất phiên bản Chrome major từ chuỗi User-Agent.
  *
- * Dùng để điền vào header `sec-ch-ua` một cách động, đảm bảo Chrome version
- * trong header khớp với Chrome version trong User-Agent (tránh fingerprint anomaly).
- *
- * Lưu ý: Nếu UA không phải Chrome/Chromium (ví dụ Firefox, Safari thuần),
- * hàm trả về "130" làm giá trị mặc định an toàn thay vì throw error.
- *
  * @returns Phiên bản Chrome major dạng string, ví dụ: "130", "133"
  */
 export declare function getChromeVersionFromUA(userAgent: string | undefined): string;
@@ -91,9 +48,6 @@ export declare function getBrowserLanguage(language: string | undefined): string
 /**
  * Sinh bộ header Sec-CH-UA nhất quán theo User-Agent (chỉ khi là Chromium/Chrome).
  *
- * Nếu User-Agent là Firefox/Safari, hàm sẽ trả về object rỗng nhằm tránh
- * tạo ra dị thường Browser Mismatch.
- *
  * @param userAgent Chuỗi User-Agent của client
  * @returns Record chứa các header sec-ch-ua-* hoặc object rỗng
  */
@@ -126,7 +80,6 @@ export declare function getGifMetaData(ctx: ContextBase, filePath: string): Prom
     width: number;
     height: number;
 }>;
-export declare function decodeEventData(parsed: Record<string, unknown>, cipherKey?: string): Promise<any>;
 export declare function getMd5LargeFileObject(source: AttachmentSource, fileSize: number): Promise<{
     currentChunk: number;
     data: string;
@@ -152,7 +105,7 @@ export declare function getFileName(e: string): string;
 export declare function removeUndefinedKeys(e: Record<string, unknown>): Record<string, unknown>;
 export declare function getGroupEventType(act: string): GroupEventType;
 export declare function getFriendEventType(act: string): FriendEventType;
-type ZaloResponse<T> = {
+export type ZaloResponse<T> = {
     data: T | null;
     error: {
         message: string;
@@ -170,99 +123,16 @@ export type FactoryUtils<T> = {
 };
 export declare function apiFactory<T>(): <K extends (api: API, ctx: ContextSession, utils: FactoryUtils<T>) => unknown>(callback: K) => (ctx: ContextBase, api: API) => ReturnType<K>;
 export declare function generateZaloUUID(userAgent: string): string;
-/**
- * Encrypts a 4-digit PIN to a 32-character hex string
- * @param pin 4-digit PIN number
- * @returns 32-character hex string
- */
-export declare function encryptPin(pin: string): string;
-/**
- * Decrypts a 32-character hex string back to 4-digit PIN
- * Note: This is a one-way hash, so we can only verify if a PIN matches the hash
- * @param encryptedPin 32-character hex string
- * @param pin 4-digit PIN to verify
- * @returns true if the PIN matches the hash
- *
- * @example
- * const encryptedPin = (await api.getHiddenConversations()).pin;
- * checking pin created..
- * const isValid = validatePin(encryptedPin, "1234"); // true if pin created is 1234
- * const isInvalid = validatePin(encryptedPin, "5678"); // false if not pin created is 5678
- */
-export declare function validatePin(encryptedPin: string, pin: string): boolean;
 /**
  * Converts a hex color code to a negative color number used by Zalo API
  * @param hex Hex color code (e.g. '#00FF00' or '00FF00')
  * @returns Negative color number (e.g. -16711936)
- *
- * @example
- * const negativeColor = hexToNegativeColor('#00FF00'); // Result: -16711936
  */
 export declare function hexToNegativeColor(hex: string): number;
 /**
  * Converts a negative color number from Zalo API to hex color code
  * @param negativeColor Negative color number (e.g. -16711936)
  * @returns Hex color code (e.g. '#00FF00')
- *
- * @example
- * const hexColor = negativeColorToHex(-16711936); // Result: '#00FF00'
  */
 export declare function negativeColorToHex(negativeColor: number): string;
 export declare function normalizeHolderName(input?: string): string | undefined;
-/**
- * Generates an RSA 2048-bit key pair for mobile message synchronization (`pull_mobile_msg`)
- * @returns Object containing public and private keys in both PEM and Base64 formats
- */
-export declare function generateRSAKeyPair(): {
-    publicKeyBase64: string;
-    privateKeyBase64: string;
-    publicKey: string;
-    privateKey: string;
-};
-/**
- * Pure-BigInt RSA CRT PKCS#1 v1.5 decryption fallback for Node.js environments
- * where OpenSSL blocks `RSA_PKCS1_PADDING` in `crypto.privateDecrypt` (CVE-2023-46809).
- */
-export declare function rsaDecryptPkcs1Manual(privateKeyPem: string, cipher: Buffer): Buffer;
-/**
- * Decrypt `encrypted_key` from `syncmsg_info` using RSA private key with PKCS#1 v1.5 scheme.
- * Automatically falls back to pure-BigInt CRT decryption if OpenSSL disables `RSA_PKCS1_PADDING`.
- *
- * @param privateKey - RSA private key in PEM format
- * @param encryptedBase64 - Base64 encoded `encrypted_key` from `syncmsg_info`
- * @returns Raw decrypted bytes (typically 16-32 bytes; use `deriveZdbAesKey` for ZDB4.0 AES-256-CBC key)
- */
-export declare function decryptWithPrivateKey(privateKey: string, encryptedBase64: string): Buffer;
-/**
- * Derives the 32-byte AES-256-CBC key for Zalo ZDB4.0 (`.db.crypt`) backup files
- * from the raw RSA-decrypted bytes: first 32 uppercase hex characters as ASCII bytes.
- */
-export declare function deriveZdbAesKey(decryptedRsaBytes: Buffer): Buffer;
-/**
- * Decrypts a Zalo ZDB4.0 (`.db.crypt`) backup buffer into its plaintext ZDB4.0 container
- * (header + table of contents + XZ stream) using 64KB independent AES-256-CBC chunks (`IV = 0`).
- */
-export declare function decryptZdbBuffer(zdbBuffer: Buffer, aesKey: Buffer): Buffer;
-export type ZdbTocEntry = {
-    name: string;
-    size: number;
-};
-/**
- * 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.
- */
-export declare function parseZdbHeader(zdbPlaintext: Buffer): {
-    entries: ZdbTocEntry[];
-    xzOffset: number;
-};
-/**
- * Encrypts a plaintext string for ZCloud / ZFamily APIs (`CLOUD_API` / `CLOUD_FAMILY_API`, module `"98yS"`),
- * using AES-256-CBC with a random 16-byte IV prepended to the ciphertext before Base64 encoding.
- */
-export declare function encryptZCloudAES(plainText: string, base64Key: string): string;
-/**
- * Decrypts a Base64 payload from ZCloud / ZFamily APIs (`CLOUD_API` / `CLOUD_FAMILY_API`, module `"98yS"`),
- * extracting the first 16 bytes as the AES-256-CBC IV and the remainder as PKCS#7-padded ciphertext.
- */
-export declare function decryptZCloudAES(base64CipherText: string, base64Key: string): string;
-export {};