mezon-sdk 2.8.28 → 2.8.29

package/dist/esm/mezon-client/client/MezonClient.js

@@ -1,491 +1,106 @@
-// src/client/MezonClient.ts
-import { EventEmitter } from "events";
-import { CacheManager } from "../utils/CacheManager";
-import { Clan } from "../structures/Clan";
-import { TextChannel } from "../structures/TextChannel";
-// import { User } from "../structures/User";
-import { Message } from "../structures/Message";
-import { MezonApi } from "../../api";
-import { SocketManager } from "../manager/socket_manager";
-import { SessionManager } from "../manager/session_manager";
-import { EventManager } from "../manager/event_manager";
-import { WebSocketAdapterPb } from "../../web_socket_adapter_pb";
+import { MezonClientCore } from "./MezonClientCore";
 import { ChannelType, Events, TypeMessage } from "../../constants";
-import { generateSnowflakeId, isValidUserId, parseUrlToHostAndSSL, sleep, waitFor2nTimeout, } from "../../utils/helper";
-import { ChannelManager } from "../manager/channel_manager";
 import { User } from "../structures/User";
-import { AsyncThrottleQueue } from "../utils/AsyncThrottleQueue";
-import { MessageDatabase } from "../../sqlite/MessageDatabase";
-import { ETransferType, MmnClient, ZkClient, } from "mmn-client-js";
-const MAX_TIME_RETRY = 10;
-const DEFAULT_HOST = "gw.mezon.ai";
-const DEFAULT_PORT = "443";
-const DEFAULT_API_KEY = "";
-const DEFAULT_SSL = true;
-const DEFAULT_TIMEOUT_MS = 7000;
-const DEFAULT_MMN_API = "https://dong.mezon.ai/mmn-api/";
-const DEFAULT_ZK_API = "https://dong.mezon.ai/zk-api/";
-export class MezonClient extends EventEmitter {
-    token;
-    clientId;
-    host;
-    useSSL;
-    port;
-    timeout;
-    loginBasePath;
-    mmnApiUrl;
-    zkApiUrl;
-    keyGen;
-    addressMMN;
-    zkProofs;
-    apiClient;
-    _mmnClient;
-    _zkClient;
-    socketManager;
-    channelManager;
-    sessionManager;
-    eventManager;
-    messageQueue = new AsyncThrottleQueue();
-    clans;
-    channels;
-    messageDB;
+import { Clan } from "../structures/Clan";
+export class MezonClient extends MezonClientCore {
+    _internalListenersBound = false;
     constructor(config) {
-        super();
-        const { botId, token = DEFAULT_API_KEY, host = DEFAULT_HOST, port = DEFAULT_PORT, useSSL = DEFAULT_SSL, timeout = DEFAULT_TIMEOUT_MS, mmnApiUrl = DEFAULT_MMN_API, zkApiUrl = DEFAULT_ZK_API, } = config;
-        if (!botId)
-            throw new Error("botId is required");
-        if (!token)
-            throw new Error("token is required");
-        const scheme = useSSL ? "https://" : "http://";
-        this.token = token;
-        this.clientId = botId;
-        this.host = host;
-        this.port = port;
-        this.useSSL = useSSL;
-        this.timeout = timeout;
-        this.loginBasePath = `${scheme}${host}:${port}`;
-        this.mmnApiUrl = mmnApiUrl;
-        this.zkApiUrl = zkApiUrl;
-        this.messageDB = new MessageDatabase();
-    }
-    get mmnClient() {
-        if (!this._mmnClient) {
-            throw new Error("MmnClient not initialized");
-        }
-        return this._mmnClient;
-    }
-    get zkClient() {
-        if (!this._zkClient) {
-            throw new Error("ZkClient not initialized");
-        }
-        return this._zkClient;
+        super(config);
     }
     initManager(basePath, sessionApi) {
-        this.eventManager = new EventManager();
-        this.clans = new CacheManager(this._fetchClanFromAPI.bind(this));
-        this.channels = new CacheManager(this._fetchChannelFromAPI.bind(this));
-        this.apiClient = new MezonApi(this.token, basePath, this.timeout);
-        this.sessionManager = new SessionManager(this.apiClient, sessionApi);
-        this.socketManager = new SocketManager(this.host, this.port, this.useSSL, new WebSocketAdapterPb(), this.apiClient, this.eventManager, this.messageQueue, this, this.messageDB);
-        this.channelManager = new ChannelManager(this.apiClient, this.socketManager, this.sessionManager);
-        if (this.mmnApiUrl) {
-            this._mmnClient = new MmnClient({
-                baseUrl: this.mmnApiUrl,
-                timeout: this.timeout,
-            });
-        }
-        if (this.zkApiUrl) {
-            this._zkClient = new ZkClient({
-                endpoint: this.zkApiUrl,
-                timeout: this.timeout,
-            });
-        }
-    }
-    async handleClientLogin() {
-        const tempApiClient = new MezonApi(this.token, this.loginBasePath, this.timeout);
-        const tempSessionManager = new SessionManager(tempApiClient);
-        let sessionApi = null;
-        try {
-            sessionApi = await tempSessionManager.authenticate(this.clientId, this.token);
-        }
-        catch (error) {
-            this.socketManager?.closeSocket();
-            throw new Error("Some thing went wrong, please reset bot!");
-        }
-        if (sessionApi?.api_url) {
-            const { host, port, useSSL } = parseUrlToHostAndSSL(sessionApi.api_url);
-            this.host = host;
-            this.port = port || (useSSL ? "443" : "80");
-            this.useSSL = useSSL;
-            const scheme = this.useSSL ? "https://" : "http://";
-            const basePath = `${scheme}${this.host}:${this.port}`;
-            this.initManager(basePath, sessionApi);
-        }
-        const sessionConnected = await this.socketManager.connect(sessionApi);
-        if (sessionConnected?.token) {
-            await this.socketManager.connectSocket(sessionConnected.token);
-            await this.channelManager.initAllDmChannels(sessionConnected.token);
-        }
-        this.emit("ready");
-        return JSON.stringify(sessionApi ?? {});
-    }
-    /** Login bot */
-    async login() {
-        try {
-            return await waitFor2nTimeout(() => this.handleClientLogin(), MAX_TIME_RETRY);
-        }
-        catch (error) {
-            this.socketManager?.closeSocket();
-            throw new Error(`Some thing went wrong, please reset bot!. ${error}`);
-        }
-    }
-    /** Create DM channel */
-    async createDMchannel(userId) {
-        try {
-            if (!isValidUserId(userId))
-                return null;
-            const socket = this.socketManager.getSocket();
-            const request = {
-                clan_id: "",
-                channel_id: "0",
-                category_id: "0",
-                type: ChannelType.CHANNEL_TYPE_DM,
-                user_ids: [userId],
-                channel_private: 1,
-            };
-            try {
-                const channelDM = await this.apiClient.createChannelDesc(this.sessionManager.getSession().token, request);
-                if (channelDM) {
-                    await sleep(100);
-                    await socket.joinChat(channelDM.clan_id, channelDM.channel_id, channelDM.type, false);
-                    const clanDm = this.clans.get("0");
-                    if (clanDm) {
-                        const userRaw = {
-                            id: userId,
-                            dmChannelId: channelDM.channel_id,
-                        };
-                        const user = new User(userRaw, clanDm, this.messageQueue, this.socketManager, this.channelManager);
-                        clanDm.users.set(userId, user);
-                    }
-                    return channelDM;
-                }
-            }
-            catch (error) {
-                console.log("error createDMchannel", userId, error?.status);
-            }
-            return null;
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    async getEphemeralKeyPair() {
-        if (!this._mmnClient) {
-            throw new Error("MmnClient not initialized");
-        }
-        return this._mmnClient.generateEphemeralKeyPair();
-    }
-    async getAddress(user_id) {
-        if (!this._mmnClient) {
-            throw new Error("MmnClient not initialized");
-        }
-        return this._mmnClient.getAddressFromUserId(user_id);
-    }
-    async getZkProofs(data) {
-        if (!this._zkClient) {
-            throw new Error("ZkClient not initialized");
-        }
-        const req = {
-            userId: data.user_id,
-            jwt: data.jwt,
-            address: data.address,
-            ephemeralPublicKey: data.ephemeral_public_key,
-        };
-        return this._zkClient.getZkProofs(req);
-    }
-    async getCurrentNonce(user_id, tag) {
-        if (!this._mmnClient) {
-            throw new Error("MmnClient not initialized");
-        }
-        return this._mmnClient.getCurrentNonce(user_id, tag || "pending");
-    }
-    async sendToken(tokenEvent) {
-        if (!this._mmnClient) {
-            throw new Error("MmnClient not initialized");
-        }
-        if (!this.keyGen) {
-            this.keyGen = await this.getEphemeralKeyPair();
-        }
-        if (!this.addressMMN) {
-            this.addressMMN = await this.getAddress(this.clientId);
-        }
-        if (!this.zkProofs) {
-            this.zkProofs = await this.getZkProofs({
-                user_id: this.clientId,
-                jwt: this.sessionManager.getSession()?.id_token,
-                address: this.addressMMN,
-                ephemeral_public_key: this.keyGen.publicKey,
-            });
-        }
-        const sender_id = tokenEvent?.sender_id ?? this.clientId;
-        const receiver_id = tokenEvent.receiver_id;
-        const mmn_extra_info = {
-            ExtraAttribute: tokenEvent?.extra_attribute ?? "",
-            UserSenderUsername: tokenEvent?.sender_name ?? "",
-            type: ETransferType.TransferToken,
-            ...(tokenEvent?.mmn_extra_info ?? {}),
-            UserSenderId: sender_id,
-            UserReceiverId: receiver_id,
-        };
-        const nonce = await this.getCurrentNonce(this.clientId, "pending");
-        const result = await this._mmnClient.sendTransaction({
-            sender: sender_id,
-            recipient: receiver_id,
-            amount: this._mmnClient.scaleAmountToDecimals(tokenEvent.amount),
-            nonce: nonce.nonce + 1,
-            textData: tokenEvent?.note || "No note",
-            extraInfo: mmn_extra_info,
-            publicKey: this.keyGen.publicKey,
-            privateKey: this.keyGen.privateKey,
-            zkProof: this.zkProofs.proof,
-            zkPub: this.zkProofs.public_input,
-        });
-        if (!result.ok) {
-            let errorMsg = result.error;
-            try {
-                const parsed = JSON.parse(result.error);
-                errorMsg = parsed.message || result.error;
-            }
-            catch (_) { }
-            throw new Error(`Transaction failed: ${errorMsg}`);
-        }
-        return result;
-    }
-    async addQuickMenuAccess(body) {
-        const id = generateSnowflakeId();
-        const sessionToken = this.sessionManager.getSession();
-        if (!sessionToken)
-            return;
-        const bot_id = this.clientId;
-        const payload = {
-            channel_id: "0",
-            clan_id: body?.clan_id ?? "0",
-            menu_type: body?.menu_type ?? 1,
-            action_msg: body.action_msg,
-            background: body?.background ?? "",
-            menu_name: body.menu_name,
-            id,
-            bot_id,
-        };
-        try {
-            return await this.apiClient.addQuickMenuAccess(sessionToken.token, payload);
-        }
-        catch (error) {
-            throw error;
-        }
+        super.initManager(basePath, sessionApi);
+        this._setupInternalListeners();
     }
-    async deleteQuickMenuAccess(botId) {
-        const sessionToken = this.sessionManager.getSession();
-        if (!sessionToken)
+    _setupInternalListeners() {
+        if (this._internalListenersBound)
             return;
-        const botIdPayload = botId ?? this.clientId;
-        try {
-            return await this.apiClient.deleteQuickMenuAccess(sessionToken.token, botIdPayload);
-        }
-        catch (error) {
-            throw error;
-        }
+        this._internalListenersBound = true;
+        this.on(Events.ChannelMessage.toString(), this._onChannelMessageInternal.bind(this));
+        this.on(Events.ChannelCreated.toString(), this._onChannelCreatedInternal.bind(this));
+        this.on(Events.ChannelUpdated.toString(), this._onChannelUpdatedInternal.bind(this));
+        this.on(Events.ChannelDeleted.toString(), this._onChannelDeletedInternal.bind(this));
+        this.on(Events.UserClanRemoved.toString(), this._onUserClanRemovedInternal.bind(this));
+        this.on(Events.AddClanUser.toString(), this._onAddClanUserInternal.bind(this));
+        this.on(Events.UserChannelAdded.toString(), this._onUserChannelAddedInternal.bind(this));
+        this.on(Events.TokenSend.toString(), this._onTokenSendInternal.bind(this));
+        this.on(Events.Notifications.toString(), this._onNotificationsInternal.bind(this));
     }
-    /** Listen to messages user sends on the  channel, thread */
-    async onChannelMessage(listener) {
-        this.on(Events.ChannelMessage.toString(), async (e) => {
-            // handle init cache channel, message, user
-            await this._initChannelMessageCache(e);
-            await this._initUserClanCache(e);
-            listener(e);
-        });
+    onChannelMessage(listener) {
+        this.on(Events.ChannelMessage.toString(), listener);
         return this;
     }
-    /** Listen to channel created */
     onChannelCreated(listener) {
-        this.on(Events.ChannelCreated.toString(), async (e) => {
-            this._updateCacheChannel(e);
-            listener(e);
-        });
+        this.on(Events.ChannelCreated.toString(), listener);
         return this;
     }
-    /** Listen to channel updated */
     onChannelUpdated(listener) {
-        this.on(Events.ChannelUpdated.toString(), async (e) => {
-            if (e.channel_type === ChannelType.CHANNEL_TYPE_THREAD &&
-                e.status === 1) {
-                const socket = this.socketManager.getSocket();
-                await socket.joinChat(e.clan_id, e.channel_id, e.channel_type, false);
-            }
-            this._updateCacheChannel(e);
-            listener(e);
-        });
+        this.on(Events.ChannelUpdated.toString(), listener);
         return this;
     }
-    /** Listen to channel deleted */
     onChannelDeleted(listener) {
-        this.on(Events.ChannelDeleted.toString(), async (e) => {
-            const clan = this.clans.get(e.clan_id);
-            if (!clan)
-                return;
-            this.channels.delete(e.channel_id);
-            clan.channels.delete(e.channel_id);
-            listener(e);
-        });
+        this.on(Events.ChannelDeleted.toString(), listener);
         return this;
     }
-    /** Listen to user send token to each other */
     onTokenSend(listener) {
-        this.on(Events.TokenSend.toString(), async (e) => {
-            if (e.sender_id === this.clientId) {
-                const clan = this.clans.get("0");
-                const receiver = await clan?.users.fetch(e.receiver_id);
-                await receiver?.sendDM({
-                    t: `Funds Transferred: ${(+e.amount).toLocaleString()}₫ | ${e.note}`,
-                }, TypeMessage.SendToken);
-            }
-            listener(e);
-        });
+        this.on(Events.TokenSend.toString(), listener);
         return this;
     }
-    /** Listen to user react to messages on the channel, thread */
     onMessageReaction(listener) {
         this.on(Events.MessageReaction.toString(), listener);
         return this;
     }
-    /** Listen to user react to messages on the channel, thread */
     onUserChannelRemoved(listener) {
         this.on(Events.UserChannelRemoved.toString(), listener);
         return this;
     }
-    /** Listen to user leaved/removed in the channel */
     onUserClanRemoved(listener) {
-        this.on(Events.UserClanRemoved.toString(), async (e) => {
-            const clan = this.clans.get(e.clan_id);
-            if (!clan)
-                return;
-            e.user_ids.forEach((user_id) => {
-                clan.users.delete(user_id);
-            });
-            listener(e);
-        });
+        this.on(Events.UserClanRemoved.toString(), listener);
         return this;
     }
-    /** Listen to user added in the channel */
     onUserChannelAdded(listener) {
-        this.on(Events.UserChannelAdded.toString(), async (e) => {
-            const socket = this.socketManager.getSocket();
-            if (e?.users?.some((user) => user.user_id == this.clientId)) {
-                await socket.joinChat(e.clan_id, e.channel_desc.channel_id, e.channel_desc.type, !e.channel_desc.channel_private);
-            }
-            listener(e);
-        });
+        this.on(Events.UserChannelAdded.toString(), listener);
         return this;
     }
-    /** Listen to users give coffee to each other */
     onGiveCoffee(listener) {
         this.on(Events.GiveCoffee.toString(), listener);
         return this;
     }
-    /** Listen to clan create new role */
     onRoleEvent(listener) {
         this.on(Events.RoleEvent.toString(), listener);
         return this;
     }
-    /** Listen to assigning a role to user */
     onRoleAssign(listener) {
         this.on(Events.RoleAssign.toString(), listener);
         return this;
     }
     onNotification(listener) {
-        this.on(Events.Notifications.toString(), async (e) => {
-            const notifications = e.notifications;
-            if (notifications && notifications.length) {
-                notifications.forEach(async (noti) => {
-                    const content = JSON.parse(noti?.content ?? {});
-                    if (noti.code === -2) {
-                        const session = this.sessionManager.getSession();
-                        await this.apiClient.requestFriend(session.token, content.username, noti.sender_id);
-                    }
-                });
-            }
-            listener(e);
-        });
+        this.on(Events.Notifications.toString(), listener);
         return this;
     }
-    /** Listen to user added in CLAN */
     onAddClanUser(listener) {
-        this.on(Events.AddClanUser.toString(), async (e) => {
-            if (e.user.user_id === this.clientId) {
-                this.socketManager.getSocket().joinClanChat(e.clan_id);
-                const clan = this.clans.get(e.clan_id);
-                if (!clan) {
-                    const clanObj = new Clan({
-                        id: e.clan_id,
-                        name: "unknown",
-                        welcome_channel_id: "",
-                        clan_name: "",
-                    }, this, this.apiClient, this.socketManager, this.sessionManager.getSession()?.token, this.messageQueue, this.messageDB);
-                    await clanObj.loadChannels();
-                    this.clans.set(e.clan_id, clanObj);
-                }
-            }
-            else {
-                const userRaw = {
-                    id: e.user.user_id,
-                    username: e.user.username,
-                    clan_nick: "",
-                    clan_avatar: "",
-                    avartar: e.user.avatar,
-                    display_name: e.user.display_name,
-                    dmChannelId: "",
-                };
-                const clan = this.clans.get(e.clan_id);
-                if (clan) {
-                    const user = new User(userRaw, clan, this.messageQueue, this.socketManager, this.channelManager);
-                    clan.users.set(e.user.user_id, user);
-                }
-                const clanDm = this.clans.get("0");
-                if (clanDm) {
-                    const user = new User(userRaw, clanDm, this.messageQueue, this.socketManager, this.channelManager);
-                    clanDm.users.set(e.user.user_id, user);
-                }
-            }
-            listener(e);
-        });
+        this.on(Events.AddClanUser.toString(), listener);
         return this;
     }
-    /** Listen to clan create a new event */
     onClanEventCreated(listener) {
         this.on(Events.ClanEventCreated.toString(), listener);
         return this;
     }
-    /** Listen to user lick a button on embed message */
     onMessageButtonClicked(listener) {
         this.on(Events.MessageButtonClicked.toString(), listener);
         return this;
     }
-    /** Listen to user joined a stream room */
     onStreamingJoinedEvent(listener) {
         this.on(Events.StreamingJoinedEvent.toString(), listener);
         return this;
     }
-    /** Listen to user leaved a stream room */
     onStreamingLeavedEvent(listener) {
         this.on(Events.StreamingLeavedEvent.toString(), listener);
         return this;
     }
-    /** Listen to user selected a input dropdown */
     onDropdownBoxSelected(listener) {
         this.on(Events.DropdownBoxSelected.toString(), listener);
         return this;
     }
-    /** Listen to user accepted call 1-1 */
     onWebrtcSignalingFwd(listener) {
         this.on(Events.WebrtcSignalingFwd.toString(), listener);
         return this;
@@ -510,135 +125,98 @@ export class MezonClient extends EventEmitter {
         this.on(Events.QuickMenu.toString(), listener);
         return this;
     }
-    closeSocket() {
-        this.socketManager.closeSocket();
-        this.eventManager = new EventManager(); // Reset event manager
-    }
-    getListFriends(limit, state, cursor) {
-        const session = this.sessionManager.getSession();
-        return this.apiClient.getListFriends(session.token, limit, state, cursor);
-    }
-    acceptFriend(userId, username) {
-        const session = this.sessionManager.getSession();
-        return this.apiClient.requestFriend(session.token, username, userId);
-    }
-    addFriend(username) {
-        const session = this.sessionManager.getSession();
-        return this.apiClient.requestFriend(session.token, username);
-    }
-    async _fetchClanFromAPI(id) {
-        throw Error(`Can not find clan ${id}!`);
-    }
-    async _fetchChannelFromAPI(id) {
-        try {
-            const session = this.sessionManager.getSession();
-            const channelDetail = await this.apiClient.listChannelDetail(session.token, id);
-            const clanId = channelDetail?.clan_id ?? "0";
-            const clan = this.clans.get(clanId);
-            const channel = new TextChannel(channelDetail, clan, this.socketManager, this.messageQueue, this.messageDB);
-            this.channels.set(channel.id, channel);
-            clan?.channels.set(channel.id, channel);
-            return channel;
-        }
-        catch (error) {
-            throw Error(`Can not find channel ${id}!`);
+    async _onChannelMessageInternal(e) {
+        await this._initChannelMessageCache(e);
+        await this._initUserClanCache(e);
+    }
+    async _onChannelCreatedInternal(e) {
+        this._updateCacheChannel(e);
+    }
+    async _onChannelUpdatedInternal(e) {
+        if (e.channel_type === ChannelType.CHANNEL_TYPE_THREAD && e.status === 1) {
+            const socket = this.socketManager.getSocket();
+            await socket.joinChat(e.clan_id, e.channel_id, e.channel_type, false);
         }
+        this._updateCacheChannel(e);
     }
-    async _initChannelMessageCache(e) {
-        const { clan_id, channel_id, sender_id, message_id, content, reactions, mentions, attachments, references, create_time_seconds, topic_id, } = e;
-        try {
-            if (clan_id && clan_id !== "0") {
-                const clan = this.clans.get(clan_id);
-                if (clan) {
-                    try {
-                        await clan.loadChannels();
-                    }
-                    catch (err) {
-                        console.warn("Failed to load channels", err);
-                    }
-                }
+    async _onChannelDeletedInternal(e) {
+        const clan = this.clans.get(e.clan_id);
+        if (!clan)
+            return;
+        this.channels.delete(e.channel_id);
+        clan.channels.delete(e.channel_id);
+    }
+    async _onUserClanRemovedInternal(e) {
+        const clan = this.clans.get(e.clan_id);
+        if (!clan)
+            return;
+        e.user_ids.forEach((user_id) => {
+            clan.users.delete(user_id);
+        });
+    }
+    async _onAddClanUserInternal(e) {
+        if (e.user.user_id === this.clientId) {
+            this.socketManager.getSocket().joinClanChat(e.clan_id);
+            const clan = this.clans.get(e.clan_id);
+            if (!clan) {
+                const clanObj = new Clan({
+                    id: e.clan_id,
+                    name: "unknown",
+                    welcome_channel_id: "",
+                    clan_name: "",
+                }, this, this.apiClient, this.socketManager, this.sessionManager.getSession()?.token, this.messageQueue, this.messageDB);
+                await clanObj.loadChannels();
+                this.clans.set(e.clan_id, clanObj);
             }
-            const channel = await this.channels.fetch(channel_id).catch((err) => {
-                console.warn("Fetch channel failed", err);
-                return null;
-            });
-            if (!message_id || !channel)
-                return;
-            const messageRaw = {
-                id: message_id,
-                clan_id: clan_id,
-                channel_id: channel_id,
-                sender_id: sender_id,
-                content,
-                reactions,
-                mentions,
-                attachments,
-                references,
-                create_time_seconds,
-                topic_id,
+        }
+        else {
+            const userRaw = {
+                id: e.user.user_id,
+                username: e.user.username,
+                clan_nick: "",
+                clan_avatar: "",
+                avartar: e.user.avatar,
+                display_name: e.user.display_name,
+                dmChannelId: "",
             };
-            const message = new Message(messageRaw, channel, this.socketManager, this.messageQueue);
-            channel.messages.set(message_id, message);
-            try {
-                this.messageDB.saveMessage(e);
+            const clan = this.clans.get(e.clan_id);
+            if (clan) {
+                const user = new User(userRaw, clan, this.messageQueue, this.socketManager, this.channelManager);
+                clan.users.set(e.user.user_id, user);
             }
-            catch (err) {
-                console.warn("Failed to save message", err);
+            const clanDm = this.clans.get("0");
+            if (clanDm) {
+                const user = new User(userRaw, clanDm, this.messageQueue, this.socketManager, this.channelManager);
+                clanDm.users.set(e.user.user_id, user);
             }
         }
-        catch (error) {
-            console.log("Error initChannelMessageCache");
+    }
+    async _onUserChannelAddedInternal(e) {
+        const socket = this.socketManager.getSocket();
+        if (e?.users?.some((user) => user.user_id == this.clientId)) {
+            await socket.joinChat(e.clan_id, e.channel_desc.channel_id, e.channel_desc.type, !e.channel_desc.channel_private);
         }
     }
-    async _initUserClanCache(e) {
-        const { clan_id, sender_id, username, clan_nick, clan_avatar, avatar, display_name, } = e;
-        const clan = this.clans.get(clan_id ?? "0");
-        if (clan) {
-            const userCache = clan.users.get(sender_id);
-            const clanDm = this.clans.get("0");
-            const allDmChannels = this.channelManager.getAllDmChannels();
-            if (!userCache && sender_id !== this.clientId && allDmChannels) {
-                const userIds = Object.keys(allDmChannels ?? {}) || [];
-                userIds.forEach((id) => {
-                    if (!id)
-                        return;
-                    const user = new User({ id, dmChannelId: allDmChannels?.[id] ?? "" }, clan, this.messageQueue, this.socketManager, this.channelManager);
-                    const userDM = clanDm?.users?.get(id);
-                    if (!userDM) {
-                        clanDm?.users?.set(id, user);
-                    }
-                    const userClan = clan.users.get(id);
-                    if (!userClan) {
-                        clan.users.set(id, user);
-                    }
-                });
-            }
-            const userRaw = {
-                id: sender_id,
-                username: username,
-                clan_nick: clan_nick,
-                clan_avatar: clan_avatar,
-                avartar: avatar,
-                display_name: display_name,
-                dmChannelId: allDmChannels?.[sender_id] ?? "",
-            };
-            const user = new User(userRaw, clan, this.messageQueue, this.socketManager, this.channelManager);
-            clan.users.set(sender_id, user);
-            clanDm?.users.set(sender_id, user);
+    async _onTokenSendInternal(e) {
+        if (e.sender_id === this.clientId) {
+            const clan = this.clans.get("0");
+            const receiver = await clan?.users.fetch(e.receiver_id);
+            await receiver?.sendDM({
+                t: `Funds Transferred: ${(+e.amount).toLocaleString()}₫ | ${e.note || "Transfer funds"}`,
+            }, TypeMessage.SendToken);
         }
     }
-    _updateCacheChannel(e) {
-        const clan = this.clans.get(e.clan_id);
-        if (!clan)
-            return;
-        const channelObj = new TextChannel({
-            ...e,
-            type: e.channel_type,
-            channel_private: e.channel_private ? 1 : 0,
-        }, clan, this.socketManager, this.messageQueue, this.messageDB);
-        this.channels.set(e.channel_id, channelObj);
-        clan.channels.set(e.channel_id, channelObj);
-        this.socketManager.getSocket().joinChat;
+    async _onNotificationsInternal(e) {
+        const notifications = e.notifications;
+        if (notifications && notifications.length) {
+            for (const noti of notifications) {
+                const content = JSON.parse(noti?.content ?? "{}");
+                if (noti.code === -2) {
+                    const session = this.sessionManager.getSession();
+                    await this.apiClient.requestFriend(session.token, content.username, noti.sender_id);
+                }
+            }
+        }
     }
 }
 //# sourceMappingURL=MezonClient.js.map